通过OmniKey的非接触式卡，如何获得“UID”？

我正在尝试使用非接触式OmniKey 5321卡从智能卡读取信息读者。编辑：添加了赏金。我正在.NET 3.5程序中编写C＃3，所以这是一个Windows应用程序。该卡上印有一些信息，我会假设，卡片数据中存在某些信息（下面有卡片和读卡器的照片。）该卡上印有以下信息： 1 * 00447 21091328-32 使用OmniKey读卡器附带的诊断应用程序时，我会收到以下信息：智能卡名称：iCLASS 16KS UID：EE 74 0E 00 FB FF 12 E0 ATR：3B 8F 80 01 80 4F 0C A0 00 00 03 06 0A 00 1A 00 00 00 00 78 议定书：ISO 15693（第2部分）现在，我已经考虑了一些转换： 447十进制= 1BF十六进制（未找到） 447八进制= 295十进制（未找到BCD类型编码） 447八进制= 127十六进制（未找到）找不到447十六进制这是我的问题： “UID”号码是否是我可以依赖的唯一号码？我并不真正关心447号码，我需要知道的是，我从这张卡片中挑选的信息将在以后唯一识别它，以便我可以将其链接到卡片的所有者我如何阅读UID号码？在Windows中使用WINSCARD.DLL我可以看到每个字节都得到“ATR”数据，但UID显然不存在于该部分中。这是照片，如果它给你任何信息。

已邀请:

6 个回复

藕挝

您可以依赖UID但在您的情况下似乎被截断：

UID:EE 74 0E 00 FB FF 12 E0

Uid通常是16个字节长。你可以读这个唯一标识符（UID）：所有符合ISO标准的智能卡都具有UID编号（类似于车辆上的VIN编号）。对于为了实现互操作性，卡的UID是开放的，所有兼容的读者都可以阅读。由于该唯一号码不受密钥保护，因此读取智能卡的UID与读取感应卡，磁条卡或其他利用开放，不安全号码的技术相当。 http://www.xceedid.com/pdf/XC5937_Smart_whitepaper.pdf

眠缝

我最近花了太多时间寻找一个完整的例子，说明如何从OMNIKEY感应卡和OMNIKEY感应卡... 现在我的代码工作正常，我想分享，以便其他人可以受益。我找到的最好的代码来自SpringCard。（谢谢！）我发现的其他例子是浪费时间和误导，并且由于DllImport错误而无法正常工作......

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Runtime.InteropServices;

namespace Test
{
    public delegate void VoidDelegate();
    public delegate void CardPresented(string reader, byte[] cardData);

    public class ReaderList : IDisposable, IEnumerable<string>
    {
        public ReaderList()
        { }

        public void Dispose()
        {
            StopThread();
        }

        private Thread thread;
        private void StartThread()
        {
            if (thread != null)
                StopThread();

            thread = new Thread(Run);
            thread.IsBackground = true;
            bStopThread = false;
            thread.Start();
        }

        private void StopThread()
        {
            if (thread != null)
            {
                bStopThread = true;
                Thread.Sleep(50);
            }
            if (thread != null)
                thread.Abort();
            if (thread != null)
                thread.Join();
            thread = null;
        }

        private List<string> readerNames = new List<string>();
        private Dictionary<string, string> lastCardFound = new Dictionary<string, string>();
        public int ReaderCount
        { get { return readerNames.Count; } }

        public void Refresh()
        {
            if (thread == null)
                StartThread();
        }

        public event VoidDelegate ListChanged;
        public event CardPresented CardPresented;

        private bool bStopThread = true;
        private void Run()
        {
            IntPtr hContext = IntPtr.Zero;

            try
            {
                uint result = SCARD.EstablishContext(SCARD.SCOPE_SYSTEM, IntPtr.Zero, IntPtr.Zero, ref hContext);
                if (result != SCARD.S_SUCCESS)
                {
                    thread = null;
                    return;
                }

                uint notification_state = SCARD.STATE_UNAWARE;

                while (!bStopThread)    // loop 1 - build list, then iterate
                {
                    SCARD.ReaderState[] states = new SCARD.ReaderState[ReaderCount + 1];
                    states[0] = new SCARD.ReaderState(@"\?PNP?NOTIFICATION");
                    states[0].dwCurrentState = notification_state;

                    int iState = 0;
                    if (readerNames != null)
                        foreach (string s in readerNames)
                        {
                            iState++;
                            states[iState] = new SCARD.ReaderState(s);
                            states[iState].dwCurrentState = SCARD.STATE_UNAWARE;
                        }

                    while (!bStopThread)    // loop 2 - iterate over list built above
                    {
                        result = SCARD.GetStatusChange(hContext, 250, states, (uint)states.Length);
                        if (result == SCARD.E_TIMEOUT)
                            continue;
                        if (result != SCARD.S_SUCCESS)
                            break;

                        bool bReaderListChanged = false;
                        for (int i = 0; i < states.Length; i++)
                            if ((states[i].dwEventState & SCARD.STATE_CHANGED) != 0)
                                if (i == 0)
                                {
                                    // reader added or removed
                                    notification_state = states[0].dwEventState;

                                    // we want to replace the member in one step, rather than modifying it...
                                    List<string> tmp = GetReaderList(hContext, SCARD.GROUP_ALL_READERS);
                                    if (tmp == null)
                                        readerNames.Clear();
                                    else
                                        readerNames = tmp;

                                    if (ListChanged != null)
                                        ListChanged();
                                    bReaderListChanged = true;
                                }
                                else
                                {
                                    // card added or removed
                                    states[i].dwCurrentState = states[i].dwEventState;

                                    if ((states[i].dwEventState & SCARD.STATE_PRESENT) != 0)
                                    {
                                        byte[] cardData = new byte[states[i].cbATR];
                                        for (int j=0; j<cardData.Length; j++)
                                            cardData[j] = states[i].rgbATR[j];
                                        string thisCard = SCARD.ToHex(cardData, "");
                                        string lastCard;
                                        lastCardFound.TryGetValue(states[i].szReader, out lastCard);
                                        if (thisCard != lastCard)
                                        {
                                            lastCardFound[states[i].szReader] = thisCard;
                                            if (CardPresented != null)
                                                CardPresented(states[i].szReader, cardData);
                                        }
                                    }
                                    else
                                        lastCardFound[states[i].szReader] = "";                                        
                                }

                        if (bReaderListChanged)
                            break;  // break out of loop 2, and re-build our 'states' list

                    } // end loop 2
                } // end loop 1
            }
            catch (Exception ex)
            {
                //TODO: error logging
            }
            finally
            {
                if (hContext != IntPtr.Zero)
                    SCARD.ReleaseContext(hContext);
                thread = null;
            }
        }

        private List<string> GetReaderList(IntPtr hContext, string sGroup)
        {
            uint nStringLength = 0;
            uint result = SCARD.ListReaders(hContext, sGroup, null, ref nStringLength);
            if (result != SCARD.S_SUCCESS)
                return null;

            string sReaders = new string(' ', (int)nStringLength);
            result = SCARD.ListReaders(hContext, sGroup, sReaders, ref nStringLength);
            if (result != SCARD.S_SUCCESS)
                return null;
            List<string> list = new List<string> (sReaders.Split(''));
            for (int i = 0; i < list.Count; )
                if (list[i].Trim().Length > 0)
                    i++;
                else
                    list.RemoveAt(i);
            return list;
        }

        public IEnumerator<string> GetEnumerator()
        { return readerNames.GetEnumerator(); }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        { return readerNames.GetEnumerator(); }

    }

    public class SCARD
    {
        [DllImport("WinScard.dll", EntryPoint = "SCardEstablishContext")]
        public static extern uint EstablishContext(
            uint dwScope,
            IntPtr nNotUsed1,
            IntPtr nNotUsed2,
            ref IntPtr phContext);

        [DllImport("WinScard.dll", EntryPoint = "SCardReleaseContext")]
        public static extern uint ReleaseContext(
            IntPtr hContext);

        [DllImport("winscard.dll", EntryPoint = "SCardGetStatusChangeW", CharSet = CharSet.Unicode)]
        public static extern uint GetStatusChange(
            IntPtr hContext,
            uint dwTimeout,
            [In, Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)]
                SCARD.ReaderState[] rgReaderState,
            uint cReaders);

        [DllImport("winscard.dll", EntryPoint = "SCardListReadersW", CharSet = CharSet.Unicode)]
        public static extern uint ListReaders(
            IntPtr hContext,
            string groups,
            string readers,
            ref uint size);

        #region Error codes
        public const uint S_SUCCESS = 0x00000000;
        public const uint F_INTERNAL_ERROR = 0x80100001;
        public const uint E_CANCELLED = 0x80100002;
        public const uint E_INVALID_HANDLE = 0x80100003;
        public const uint E_INVALID_PARAMETER = 0x80100004;
        public const uint E_INVALID_TARGET = 0x80100005;
        public const uint E_NO_MEMORY = 0x80100006;
        public const uint F_WAITED_TOO_LONG = 0x80100007;
        public const uint E_INSUFFICIENT_BUFFER = 0x80100008;
        public const uint E_UNKNOWN_READER = 0x80100009;
        public const uint E_TIMEOUT = 0x8010000A;
        public const uint E_SHARING_VIOLATION = 0x8010000B;
        public const uint E_NO_SMARTCARD = 0x8010000C;
        public const uint E_UNKNOWN_CARD = 0x8010000D;
        public const uint E_CANT_DISPOSE = 0x8010000E;
        public const uint E_PROTO_MISMATCH = 0x8010000F;
        public const uint E_NOT_READY = 0x80100010;
        public const uint E_INVALID_VALUE = 0x80100011;
        public const uint E_SYSTEM_CANCELLED = 0x80100012;
        public const uint F_COMM_ERROR = 0x80100013;
        public const uint F_UNKNOWN_ERROR = 0x80100014;
        public const uint E_INVALID_ATR = 0x80100015;
        public const uint E_NOT_TRANSACTED = 0x80100016;
        public const uint E_READER_UNAVAILABLE = 0x80100017;
        public const uint P_SHUTDOWN = 0x80100018;
        public const uint E_PCI_TOO_SMALL = 0x80100019;
        public const uint E_READER_UNSUPPORTED = 0x8010001A;
        public const uint E_DUPLICATE_READER = 0x8010001B;
        public const uint E_CARD_UNSUPPORTED = 0x8010001C;
        public const uint E_NO_SERVICE = 0x8010001D;
        public const uint E_SERVICE_STOPPED = 0x8010001E;
        public const uint E_UNEXPECTED = 0x8010001F;
        public const uint E_ICC_INSTALLATION = 0x80100020;
        public const uint E_ICC_CREATEORDER = 0x80100021;
        public const uint E_UNSUPPORTED_FEATURE = 0x80100022;
        public const uint E_DIR_NOT_FOUND = 0x80100023;
        public const uint E_FILE_NOT_FOUND = 0x80100024;
        public const uint E_NO_DIR = 0x80100025;
        public const uint E_NO_FILE = 0x80100026;
        public const uint E_NO_ACCESS = 0x80100027;
        public const uint E_WRITE_TOO_MANY = 0x80100028;
        public const uint E_BAD_SEEK = 0x80100029;
        public const uint E_INVALID_CHV = 0x8010002A;
        public const uint E_UNKNOWN_RES_MNG = 0x8010002B;
        public const uint E_NO_SUCH_CERTIFICATE = 0x8010002C;
        public const uint E_CERTIFICATE_UNAVAILABLE = 0x8010002D;
        public const uint E_NO_READERS_AVAILABLE = 0x8010002E;
        public const uint E_COMM_DATA_LOST = 0x8010002F;
        public const uint E_NO_KEY_CONTAINER = 0x80100030;
        public const uint W_UNSUPPORTED_CARD = 0x80100065;
        public const uint W_UNRESPONSIVE_CARD = 0x80100066;
        public const uint W_UNPOWERED_CARD = 0x80100067;
        public const uint W_RESET_CARD = 0x80100068;
        public const uint W_REMOVED_CARD = 0x80100069;
        public const uint W_SECURITY_VIOLATION = 0x8010006A;
        public const uint W_WRONG_CHV = 0x8010006B;
        public const uint W_CHV_BLOCKED = 0x8010006C;
        public const uint W_EOF = 0x8010006D;
        public const uint W_CANCELLED_BY_USER = 0x8010006E;
        public const uint W_CARD_NOT_AUTHENTICATED = 0x8010006F;
        #endregion

        public const uint SCOPE_USER = 0;
        public const uint SCOPE_TERMINAL = 1;
        public const uint SCOPE_SYSTEM = 2;

        public const string GROUP_ALL_READERS = "SCard$AllReaders";
        public const string GROUP_DEFAULT_READERS = "SCard$DefaultReaders";
        public const string GROUP_LOCAL_READERS = "SCard$LocalReaders";
        public const string GROUP_SYSTEM_READERS = "SCard$SystemReaders";

        public const uint STATE_UNAWARE = 0x00000000;
        public const uint STATE_IGNORE = 0x00000001;
        public const uint STATE_CHANGED = 0x00000002;
        public const uint STATE_UNKNOWN = 0x00000004;
        public const uint STATE_UNAVAILABLE = 0x00000008;
        public const uint STATE_EMPTY = 0x00000010;
        public const uint STATE_PRESENT = 0x00000020;
        public const uint STATE_ATRMATCH = 0x00000040;
        public const uint STATE_EXCLUSIVE = 0x00000080;
        public const uint STATE_INUSE = 0x00000100;
        public const uint STATE_MUTE = 0x00000200;
        public const uint STATE_UNPOWERED = 0x00000400;

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct ReaderState
        {
            public ReaderState(string sName)
            {
                szReader = sName;
                pvUserData = IntPtr.Zero;
                dwCurrentState = 0;
                dwEventState = 0;
                cbATR = 0;
                rgbATR = null;
            }

            internal string szReader;
            internal IntPtr pvUserData;
            internal uint dwCurrentState;
            internal uint dwEventState;
            internal uint cbATR;    // count of bytes in rgbATR
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x24, ArraySubType = UnmanagedType.U1)]
            internal byte[] rgbATR;
        }

        public static string ToHex(byte[] ab, string sDelim)
        {
            if (ab == null) return "<NULL>";
            return ToHex(ab, 0, ab.Length, sDelim);
        }

        public static string ToHex(byte[] ab, int offset, int len, string sDelim)
        {
            if (ab == null) return "<NULL>";
            StringBuilder sb = new StringBuilder();
            len = Math.Min(offset + len, ab.Length);
            for (int i = offset; i < len; i++)
                sb.Append(String.Format("{0:x02}", ab[i]).ToUpper() + sDelim);
            return sb.ToString();
        }

    }
}

耐扫鹤胶鞭

可通过PC / SC 2.01兼容函数调用UID读取UID。对于iCLASS卡，它通常为8个字节长。其他卡返回4到8字节的UID（它就像一个电话号码，用于识别现场的多张卡，最终选择一张）。 APDU可通过标准SCardTransmit()与CLA=0xFF进行交换，以指示对非接触式存储卡的访问。渣 http://www.smartcard-api.com 注意： UID不反映卡上印刷的卡号。卡号是存储在该卡第0页的应用程序1的HID PAC应用程序中的Wiegand数据的一部分。

爆刺疤灯

唯一标识符（UID）：所有符合ISO标准智能卡提供UID号码（类似于车辆上的VIN编号）。资料来源：http：//www.accentalarms.com/specsheets/xceed/XceedIDSmartcardOverview.pdf 关于阅读UID：查看http://www.hidglobal.com/faqs.php?techCat=19，它似乎显示了如何做到这一点。

河饶办斜施

即使UID号码是标准的一部分，并且标准说它应该是全球唯一的，你必须记住，通常有制造商生产不合规（但工作）的卡。结论：只要您不在卡上放置一些独特的东西，就无法确定从卡到卡所有者的链接是否满足。

耐钨徒

来自卡的ATR（应答复位）仅说明卡格式是什么，协议和该数据的校验和。在线查看ATR解析现在您知道它是什么卡然后必须应用适当的（RS232 / RS485 / ZPL II / APDU - ISO / IEC 7816-4中定义的智能卡应用协议数据单元）命令来获取UID（取决于它是否级联1,2或3，参见ACG HF Multi ISO RFID阅读器v1.0第50页，也称为Omnikey5553 RS232） - 对于14443，它长达14个字节，占据前16个字节扇区中的前两个块（扇区0），并嵌入了校验和。（参见ISO14443协议或NXP Semiconductors MF1ICS50规范第8页）。对于15693，RS232 / RS485命令将在（S）选（Omnikey5553 RS232和USB）上返回一个完整的16字节UID，但是APDU将仅返回最后8个字节（Omnikey5022上的0xFF 0xCA 0x00 0x00 0x00），尽管它是标准至于15693，该卡一次仅响应8个字节。对于14443，您可以一次读取一个扇区（8个字节的4个块中的32个字节，在读取/写入S50之前登录到扇区）但是对于15693，您一次只能读取/写入8个字节的块，并在返回的缓冲区中有其他数据。您必须编码是否“阻止”32或8的数据。这是使用Windows API的标准SCardTransmit智能卡协议。由于诊断应用程序返回了16个字节，即卡的UID。此外，一些专有的15693使用14443倒置密钥来混淆和防止修改，其他人持有一个执行验证的微程序 - 无论是在PC上还是在卡本身上。在所有情况下，这与卡上打印的内容没有任何关系 - 我们使用印在EV1塑料卡上的CODE128C条形码，其中包含GUID，然后引用数据库上相应的UID进行交易。其他人（如Wiegand等）打印其他数据，如区号，密钥集等。当您尝试将数据写入15693时会出现其他问题 - 确保在4 char接口处结束数据，否则当您尝试在块中的现有字符上写入“0x00”时，您会遇到先前数据的问题 - 所以更新/写入卡后的皮带，支架和一段字符串的代码，以确保数据是否符合要求。如果整个块是'null'，没问题，因为数据被写成4个字符的块。不要不必要地清空卡用户区域，因为它们是基于NAND的并且具有有限的写入。（写完后再次读卡，确保写入的数据是写的！） UID在卡发行集中应该是唯一的，但它也取决于相关的卡数量顺序 - 这就是为什么序列号已经扩展了2倍（级联号码），并且一次你应该放大对UID的信任。 Apple手机违反了UID中的U - 它可以设置为模拟另一个UID。 NDEF是应该理解的卡的另一个方面 - 它在NFC NDEF标准中得到了很好的解释，只需要注意14443的OTP和LOCK区域，因为它们只有一次设置就是单向的。您可以随时使用具有NFC和TagData应用程序的Android手机进行验证。

要回复问题请先登录或注册

通过OmniKey的非接触式卡，如何获得“UID”？

6 个回复

发起人

winscard

iso_15693

smartcard_reader

问题状态

通过OmniKey的非接触式卡，如何获得“UID”？

与内容相关的链接

6 个回复

发起人

winscard

iso_15693

smartcard_reader

问题状态