Esempio n. 1
0
        public string RetrieveCardUID()
        {
            var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);

            if (sc != SCardError.Success)
            {
                MessageBox.Show("The reader did not have enough time to read, \nplease reswipe the card", "Error",
                                MessageBoxButton.OK, MessageBoxImage.Error);
                return("Failed to retrieve card UID");
            }
            var receivePci = new SCardPCI(); // IO returned protocol control information.
            var sendPci    = SCardPCI.GetPci(rfidReader.ActiveProtocol);

            var receiveBuffer = new byte[256];
            var command       = apdu.ToArray();

            sc = rfidReader.Transmit(sendPci, command, receivePci, ref receiveBuffer);

            if (sc != SCardError.Success)
            {
                MessageBox.Show("Error: " + SCardHelper.StringifyError(sc));
                return("Failed to retrieve card UID");
            }
            var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);

            rfidReader.EndTransaction(SCardReaderDisposition.Leave);
            rfidReader.Disconnect(SCardReaderDisposition.Reset);
            return(responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received, please reswipe the card");
        }
Esempio n. 2
0
        private void TransmitBytes()
        {
            // Create a new PC/SC context.
            var ctx = new SCardContext();

            ctx.Establish(SCardScope.System);
            // Connect to the reader
            var        rfidReader = new SCardReader(ctx);
            SCardError rc         = rfidReader.Connect(
                READER_NAME,
                SCardShareMode.Shared,
                SCardProtocol.T1);

            if (rc != SCardError.Success)
            {
                return;
            }
            // prepare APDU
            byte[] ucByteSend = new byte[]
            {
                0xFF,       // the instruction class
                0xCA,       // the instruction code
                0x00,       // parameter to the instruction
                0x00,       // parameter to the instruction
                0x00        // size of I/O transfer
            };
            rc = rfidReader.BeginTransaction();
            if (rc != SCardError.Success)
            {
                MessageBox.Show("Klaida: nutruko ryšys su skaitytuvu...");
            }
            SCardPCI ioreq = new SCardPCI();   // IO returned protocol control information.

            byte[] ucByteReceive = new byte[10];
            rc = rfidReader.Transmit(
                SCardPCI.T1, // Protocol control information, T0, T1 and Raw
                             // are global defined protocol header structures.
                ucByteSend,  // the actual data to be written to the card
                ioreq,       // The returned protocol control information
                ref ucByteReceive);
            if (rc == SCardError.Success)
            {
                var byteList = new List <byte>(ucByteReceive);
                byteList.RemoveRange(byteList.Count - 2, 2);
                ucByteReceive = byteList.ToArray();
                backgroundNFCListener.ReportProgress(0,
                                                     String.Format(BitConverter.ToString(ucByteReceive).Replace("-", "")));
            }
            else
            {
                backgroundNFCListener.ReportProgress(0,
                                                     String.Format("Klaida: " + SCardHelper.StringifyError(rc)));
            }
            rfidReader.EndTransaction(SCardReaderDisposition.Leave);
            rfidReader.Disconnect(SCardReaderDisposition.Reset);
            ctx.Release();
        }
Esempio n. 3
0
        public string ReadRfid()
        {
            string result = null;

            if (_InitRfid())
            {
                byte[] sendBuffer =
                {
                    0xFF,
                    0xCA,
                    0x00,
                    0x00,
                    0x00
                };
                byte[] receiveBuffer = new byte[10];

                SCardError errorCode = _reader.BeginTransaction();
                if (errorCode != SCardError.Success)
                {
                    throw new ApplicationException("НЕ УДАЛОСЬ НАЧАТЬ ТРАНЗАКЦИЮ");
                }
                SCardPCI ioreq   = new SCardPCI(); // создаём пустой объект
                IntPtr   sendPci = SCardPCI.GetPci(_reader.ActiveProtocol);
                errorCode = _reader.Transmit
                            (
                    sendPci,
                    sendBuffer,
                    ioreq,
                    ref receiveBuffer
                            );
                if (errorCode == SCardError.Success)
                {
                    StringBuilder builder = new StringBuilder(8);
                    for (int i = receiveBuffer.Length - 3; i >= 0; i--)
                    {
                        builder.AppendFormat("{0:X2}", receiveBuffer[i]);
                    }
                    result = builder.ToString();
                }
                else
                {
                    throw new ApplicationException
                              (string.Format(
                                  "ОШИБКА: {0}",
                                  SCardHelper.StringifyError(errorCode)
                                  ));
                }

                _reader.EndTransaction(SCardReaderDisposition.Leave);
            }

            _CloseRfid();

            return(result);
        }
Esempio n. 4
0
 private string GetUid(string readerName)
 {
     using (var context = new SCardContext())
     {
         context.Establish(SCardScope.System);
         using (var rfidReader = new SCardReader(context))
         {
             var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);
             if (sc != SCardError.Success)
             {
                 Debug.WriteLine($"PcscWrapper: Could not connect to reader {readerName}:\n{SCardHelper.StringifyError(sc)}");
                 return(null);
             }
             var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
             {
                 CLA         = 0xFF,
                 Instruction = InstructionCode.GetData,
                 P1          = 0x00,
                 P2          = 0x00,
                 Le          = 0 // We don't know the ID tag size
             };
             sc = rfidReader.BeginTransaction();
             if (sc != SCardError.Success)
             {
                 Debug.WriteLine("PcscWrapper: Could not begin transaction.");
                 return(null);
             }
             var receivePci    = new SCardPCI();  // IO returned protocol control information.
             var sendPci       = SCardPCI.GetPci(rfidReader.ActiveProtocol);
             var receiveBuffer = new byte[256];
             var command       = apdu.ToArray();
             sc = rfidReader.Transmit(
                 sendPci,                // Protocol Control Information (T0, T1 or Raw)
                 command,                // command APDU
                 receivePci,             // returning Protocol Control Information
                 ref receiveBuffer);     // data buffer
             if (sc != SCardError.Success)
             {
                 Debug.WriteLine("Error: " + SCardHelper.StringifyError(sc));
             }
             var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);
             rfidReader.EndTransaction(SCardReaderDisposition.Leave);
             rfidReader.Disconnect(SCardReaderDisposition.Reset);
             if (responseApdu.HasData)
             {
                 string uid = BitConverter.ToString(responseApdu.GetData()).Replace("-", "").ToUpper();
                 return(uid);
             }
         }
     }
     return(null);
 }
Esempio n. 5
0
        /// <summary>
        ///   Retrieves the UID of a card that is currently connected to the given
        ///   reader.
        /// </summary>
        /// <param name="readername"></param>
        /// <exception cref="Exception">Could not begin transaction.</exception>
        private byte[] UidFromConnectedCard(string readername)
        {
            SCardReader rfidReader = new SCardReader(Context);
            SCardError  resultCode = rfidReader.Connect(readername, SCardShareMode.Shared, SCardProtocol.Any);

            if (resultCode != SCardError.Success)
            {
                throw new Exception("Unable to connect to RFID card / chip. Error: " + SCardHelper.StringifyError(resultCode));
            }

            // prepare APDU
            byte[] payload = new byte[] {
                0xFF, // the instruction class
                0xCA, // the instruction code
                0x00, // parameter to the instruction
                0x00, // parameter to the instruction
                0x00  // size of I/O transfer
            };
            byte[] receiveBuffer = new byte[10];

            resultCode = rfidReader.BeginTransaction();
            if (resultCode != SCardError.Success)
            {
                throw new Exception("Could not begin transaction.");
            }

            SCardPCI ioreq = new SCardPCI();

            IntPtr protocolControlInformation = SCardPCI.GetPci(rfidReader.ActiveProtocol);

            resultCode = rfidReader.Transmit(protocolControlInformation, payload, ioreq, ref receiveBuffer);

            if (resultCode != SCardError.Success)
            {
                Log.Error(SCardHelper.StringifyError(resultCode));
                receiveBuffer = null;
            }

            rfidReader.EndTransaction(SCardReaderDisposition.Leave);
            rfidReader.Disconnect(SCardReaderDisposition.Reset);

            return(receiveBuffer);
        }
Esempio n. 6
0
        public static (bool Success, string Report) GetUid(IContextFactory contextFactory, string readerName)
        {
            try
            {
                using (var ctx = contextFactory.Establish(SCardScope.System))
                {
                    using (var rfidReader = new SCardReader(ctx))
                    {
                        try
                        {
                            var rc = rfidReader.SetAttrib(SCardAttribute.AsyncProtocolTypes, new[] { (byte)1 }); //

                            var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);
                            if (sc != SCardError.Success)
                            {
                                return(false, SCardHelper.StringifyError(sc));
                            }
                            else
                            {
                                var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
                                {
                                    CLA         = 0xFF,
                                    Instruction = InstructionCode.GetData,
                                    P1          = 0x00,
                                    P2          = 0x00,
                                    Le          = 0                 // We don't know the ID tag size
                                };

                                sc = rfidReader.BeginTransaction();
                                if (sc != SCardError.Success)
                                {
                                    return(false, "Could not begin transaction.");
                                }
                                else
                                {
                                    var receiveBuffer = new byte[256];

                                    sc = rfidReader.Transmit(
                                        SCardPCI.GetPci(rfidReader.ActiveProtocol), // Protocol Control Information (T0, T1 or Raw)
                                        apdu.ToArray(),                             // command APDU
                                        new SCardPCI(),                             // returning Protocol Control Information
                                        ref receiveBuffer);                         // data buffer

                                    if (sc != SCardError.Success)
                                    {
                                        return(false, SCardHelper.StringifyError(sc));
                                    }

                                    var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);
                                    if (responseApdu.HasData)
                                    {
                                        if (!(responseApdu.SW1 == 0x90 && responseApdu.SW2 == 0))
                                        {
                                            return(false, "Not 90-00");
                                        }

                                        var uid = responseApdu.GetData();

                                        return(true, BitConverter.ToString(uid).Replace("-", ""));
                                    }
                                    else
                                    {
                                        return(false, "ResponseApdu has no data");
                                    }
                                }
                            }
                        }
                        catch (Exception ex) { return(false, ex.Message); }
                        finally
                        {
                            rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                            rfidReader.Disconnect(SCardReaderDisposition.Reset);
                        }
                    }
                }
            }
            catch (Exception ex) { return(false, ex.Message); }
        }
Esempio n. 7
0
        public string GetCardUID(string cardReaderName)
        {
            try
            {
                var contextFactory = ContextFactory.Instance;
                using (var context = contextFactory.Establish(SCardScope.System))
                {
                    using (var rfidReader = new SCardReader(context))
                    {
                        var sc = rfidReader.Connect(cardReaderName, SCardShareMode.Shared, SCardProtocol.Any);
                        if (sc != SCardError.Success)
                        {
                            Debug.WriteLine(string.Format("GetCardUID: Could not connect to reader {0}:\n{1}",
                                                          cardReaderName,
                                                          SCardHelper.StringifyError(sc)));
                            return(string.Empty);
                        }

                        var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
                        {
                            CLA         = 0xFF,
                            Instruction = InstructionCode.GetData,
                            P1          = 0x00,
                            P2          = 0x00,
                            Le          = 0 // We don't know the ID tag size
                        };

                        sc = rfidReader.BeginTransaction();
                        if (sc != SCardError.Success)
                        {
                            Debug.WriteLine("GetCardUID: Could not begin transaction.");
                            return(string.Empty);
                        }

                        Debug.WriteLine("Retrieving the UID .... ");

                        var receivePci = new SCardPCI(); // IO returned protocol control information.
                        var sendPci    = SCardPCI.GetPci(rfidReader.ActiveProtocol);

                        var receiveBuffer = new byte[256];
                        var command       = apdu.ToArray();

                        sc = rfidReader.Transmit(
                            sendPci,            // Protocol Control Information (T0, T1 or Raw)
                            command,            // command APDU
                            receivePci,         // returning Protocol Control Information
                            ref receiveBuffer); // data buffer

                        if (sc != SCardError.Success)
                        {
                            Debug.WriteLine("Error: " + SCardHelper.StringifyError(sc));
                            return(string.Empty);
                        }

                        var    responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);
                        string cardUID      = responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received";

                        rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                        rfidReader.Disconnect(SCardReaderDisposition.Reset);

                        return(cardUID);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("GetCardUID exception: CardReaderName: " + cardReaderName + ". Error: " + ex.ToString());
                return(string.Empty);
            }
        }
Esempio n. 8
0
        static void Main(string[] args)
        {
            SCardContext ctx = new SCardContext();

            ctx.Establish(SCardScope.System);

            string[] readernames = ctx.GetReaders();
            if (readernames == null || readernames.Length < 1)
            {
                throw new Exception("You need at least one reader in order to run this example.");
            }

            // Show available readers.
            Console.WriteLine("Available readers: ");
            for (int i = 0; i < readernames.Length; i++)
            {
                Console.WriteLine("[" + i + "] " + readernames[i]);
            }

            int num = 0;

            if (readernames.Length > 1)
            {
                // Ask the user which one to choose.
                Console.Write("Which reader is an RFID reader? ");
                string relin = Console.ReadLine();
                if (!(int.TryParse(relin, out num)) ||
                    num < 0 ||
                    num > readernames.Length)
                {
                    Console.WriteLine("An invalid number has been entered. Exiting.");
                    return;
                }
            }

            string readername = readernames[num];

            SCardReader RFIDReader = new SCardReader(ctx);
            SCardError  rc         = RFIDReader.Connect(
                readername,
                SCardShareMode.Shared,
                SCardProtocol.Any);

            if (rc != SCardError.Success)
            {
                Console.WriteLine("Unable to connect to RFID card / chip. Error: " +
                                  SCardHelper.StringifyError(rc));
                return;
            }

            // prepare APDU
            byte[] ucByteSend = new byte[]
            {
                0xFF,   // the instruction class
                0xCA,   // the instruction code
                0x00,   // parameter to the instruction
                0x00,   // parameter to the instruction
                0x00    // size of I/O transfer
            };
            byte[] ucByteReceive = new byte[10];

            Console.Out.WriteLine("Retrieving the UID .... ");

            rc = RFIDReader.BeginTransaction();
            if (rc != SCardError.Success)
            {
                throw new Exception("Could not begin transaction.");
            }

            SCardPCI ioreq = new SCardPCI();    /* creates an empty object (null).
                                                 * IO returned protocol control information.
                                                 */
            IntPtr sendPci = SCardPCI.GetPci(RFIDReader.ActiveProtocol);

            rc = RFIDReader.Transmit(
                sendPci,    /* Protocol control information, T0, T1 and Raw
                             * are global defined protocol header structures.
                             */
                ucByteSend, /* the actual data to be written to the card */
                ioreq,      /* The returned protocol control information */
                ref ucByteReceive);

            if (rc == SCardError.Success)
            {
                Console.Write("Uid: ");
                for (int i = 0; i < (ucByteReceive.Length); i++)
                {
                    Console.Write("{0:X2} ", ucByteReceive[i]);
                }
                Console.WriteLine("");
            }
            else
            {
                Console.WriteLine("Error: " + SCardHelper.StringifyError(rc));
            }

            RFIDReader.EndTransaction(SCardReaderDisposition.Leave);
            RFIDReader.Disconnect(SCardReaderDisposition.Reset);

            return;
        }
Esempio n. 9
0
        // Obsługa przycisku wysłania komend
        private void ButtonTransmitCommand_Click(object sender, EventArgs e)
        {
            // Utworzenie sesji połączenia
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System))
            {
                // Pobranie nazw czytników
                var readerNames = context.GetReaders();
                if (NoReaderFound(readerNames))
                {
                    MessageBox.Show("Brak podłączonych urządzeń");
                    return;
                }

                // Przypisanie nazwy czytnika
                var readerName = readerNames[0];
                if (readerName == null)
                {
                    return;
                }

                using (var rfidReader = new SCardReader(context))
                {
                    //przypisanie połaczenia za pośrednictwerm RFID
                    var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);
                    if (sc != SCardError.Success) // W przypadku niepowodzenia
                    {
                        MessageBox.Show("Brak połączenia" +
                                        readerName +
                                        SCardHelper.StringifyError(sc));

                        return;
                    }
                    // pobranie komendy z pola tekstowego
                    byte[] command = Encoding.ASCII.GetBytes(textBoxCommand.Text);

                    sc = rfidReader.BeginTransaction();
                    if (sc != SCardError.Success)
                    {
                        MessageBox.Show("");
                        return;
                    }

                    var receivePci    = new SCardPCI(); // IO zwraca protocol control information.
                    var sendPci       = SCardPCI.GetPci(rfidReader.ActiveProtocol);
                    var receiveBuffer = new byte[256];

                    sc = rfidReader.Transmit(
                        sendPci,            // Protocol Control Information (T0, T1 or Raw)
                        command,            // command APDU
                        receivePci,         // returning Protocol Control Information
                        ref receiveBuffer); // data buffer

                    if (sc != SCardError.Success)
                    {
                        MessageBox.Show("BŁĄD: " + SCardHelper.StringifyError(sc));
                    }
                    // OPOWIEDZ APDU
                    var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);

                    textBoxAnswer.Text = responseApdu.SW1.ToString() + " " + responseApdu.SW2 + (responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "");

                    rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                    rfidReader.Disconnect(SCardReaderDisposition.Reset);
                }
            }
        }
Esempio n. 10
0
        public static void GetUID(string readerName)
        {
            try
            {
                var c = Console.ForegroundColor;
                //Console.Write("Scan: ");
                Console.ForegroundColor = ConsoleColor.DarkGreen;

                using (var ctx = _contextFactory.Establish(SCardScope.System))
                {
                    using (var rfidReader = new SCardReader(ctx)) // 'using' statement to make sure the reader will be disposed (disconnected) on exit
                    {
                        var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);
                        if (sc != SCardError.Success)
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.Write($"{SCardHelper.StringifyError(sc)}");
                        }
                        else
                        {
                            var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
                            {
                                CLA         = 0xFF,
                                Instruction = InstructionCode.GetData,
                                P1          = 0x00,
                                P2          = 0x00,
                                Le          = 0 // We don't know the ID tag size
                            };

                            sc = rfidReader.BeginTransaction();
                            if (sc != SCardError.Success)
                            {
                                Console.ForegroundColor = ConsoleColor.Red;
                                Console.Write("Could not begin transaction.");
                            }
                            else
                            {
                                var receiveBuffer = new byte[256];
                                var adpuSunst     = new byte[256];

                                sc = rfidReader.Transmit(
                                    SCardPCI.GetPci(rfidReader.ActiveProtocol), // Protocol Control Information (T0, T1 or Raw)
                                    apdu.ToArray(),                             // command APDU
                                    new SCardPCI(),                             // returning Protocol Control Information
                                    ref receiveBuffer);                         // data buffer

                                if (sc != SCardError.Success)
                                {
                                    Console.ForegroundColor = ConsoleColor.Red;
                                    Console.Write("\tError: " + SCardHelper.StringifyError(sc));
                                }

                                var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);
                                Console.ForegroundColor = ConsoleColor.Green;
                                Console.Write($"{(responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received"),-22}  ");

                                Console.ForegroundColor = ConsoleColor.DarkGreen;
                                Console.Write($"{responseApdu.SW1:X2}    {responseApdu.SW2:X2}    ");

                                DisplayCardAtr(reader: rfidReader);

                                rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                                rfidReader.Disconnect(SCardReaderDisposition.Reset);
                            }
                        }
                    }
                }
                Console.ForegroundColor = c;
            }
            catch (Exception ex) { var c = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"\n{ex}\n"); Console.ForegroundColor = c; }
        }
Esempio n. 11
0
        public static void Main()
        {
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System)) {
                var readerNames = context.GetReaders();
                if (NoReaderFound(readerNames))
                {
                    Console.WriteLine("You need at least one reader in order to run this example.");
                    Console.ReadKey();
                    return;
                }

                var readerName = ChooseRfidReader(readerNames);
                if (readerName == null)
                {
                    return;
                }

                // 'using' statement to make sure the reader will be disposed (disconnected) on exit
                using (var rfidReader = new SCardReader(context)) {
                    var sc = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);
                    if (sc != SCardError.Success)
                    {
                        Console.WriteLine("Could not connect to reader {0}:\n{1}",
                                          readerName,
                                          SCardHelper.StringifyError(sc));
                        Console.ReadKey();
                        return;
                    }

                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.GetData,
                        P1          = 0x00,
                        P2          = 0x00,
                        Le          = 0 // We don't know the ID tag size
                    };

                    sc = rfidReader.BeginTransaction();
                    if (sc != SCardError.Success)
                    {
                        Console.WriteLine("Could not begin transaction.");
                        Console.ReadKey();
                        return;
                    }

                    Console.WriteLine("Retrieving the UID .... ");

                    var receivePci = new SCardPCI(); // IO returned protocol control information.
                    var sendPci    = SCardPCI.GetPci(rfidReader.ActiveProtocol);

                    var receiveBuffer = new byte[256];
                    var command       = apdu.ToArray();

                    sc = rfidReader.Transmit(
                        sendPci,            // Protocol Control Information (T0, T1 or Raw)
                        command,            // command APDU
                        receivePci,         // returning Protocol Control Information
                        ref receiveBuffer); // data buffer

                    if (sc != SCardError.Success)
                    {
                        Console.WriteLine("Error: " + SCardHelper.StringifyError(sc));
                    }

                    var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);
                    Console.Write("SW1: {0:X2}, SW2: {1:X2}\nUid: {2}",
                                  responseApdu.SW1,
                                  responseApdu.SW2,
                                  responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received");

                    rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                    rfidReader.Disconnect(SCardReaderDisposition.Reset);

                    Console.ReadKey();
                }
            }
        }
Esempio n. 12
0
        private void Monitor_CardInserted(object sender, CardStatusEventArgs e)
        {
            using (var context = _contextFactory.Establish(SCardScope.System))
            {
                // 'using' statement to make sure the reader will be disposed (disconnected) on exit
                using (var rfidReader = new SCardReader(context))
                {
                    var sc = rfidReader.Connect(e.ReaderName, SCardShareMode.Shared, SCardProtocol.Any);
                    if (sc != SCardError.Success)
                    {
                        Debug.WriteLine("Could not connect to reader {0}:\n{1}",
                                        e.ReaderName,
                                        SCardHelper.StringifyError(sc));
                        return;
                    }

                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.GetData,
                        P1          = 0x00,
                        P2          = 0x00,
                        Le          = 0 // We don't know the ID tag size
                    };

                    sc = rfidReader.BeginTransaction();
                    if (sc != SCardError.Success)
                    {
                        Debug.WriteLine("Could not begin transaction.");
                        return;
                    }

                    Debug.WriteLine("Retrieving the UID .... ");

                    var receivePci = new SCardPCI(); // IO returned protocol control information.
                    var sendPci    = SCardPCI.GetPci(rfidReader.ActiveProtocol);

                    var receiveBuffer = new byte[256];
                    var command       = apdu.ToArray();

                    sc = rfidReader.Transmit(
                        sendPci,            // Protocol Control Information (T0, T1 or Raw)
                        command,            // command APDU
                        receivePci,         // returning Protocol Control Information
                        ref receiveBuffer); // data buffer

                    if (sc != SCardError.Success)
                    {
                        Debug.WriteLine("Error: " + SCardHelper.StringifyError(sc));
                    }

                    var responseApdu = new ResponseApdu(receiveBuffer, IsoCase.Case2Short, rfidReader.ActiveProtocol);

                    Debug.WriteLine("\nRaw UID: " + (responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received"));

                    rfidReader.EndTransaction(SCardReaderDisposition.Leave);
                    rfidReader.Disconnect(SCardReaderDisposition.Reset);

                    if (responseApdu.HasData)
                    {
                        SendRco(UidToRco(responseApdu.GetData()), BitConverter.ToString(responseApdu.GetData()), e.ReaderName);
                    }
                }
            }
        }
        private static string getPanNumber1(SCardContext context, string readerName)
        {
            var rfidReader = new SCardReader(context);

            byte[] readRecord = new byte[0];
            byte   x          = 0x00;
            var    sc         = rfidReader.Connect(readerName, SCardShareMode.Shared, SCardProtocol.Any);

            if (sc != SCardError.Success)
            {
                return(null);
            }

            //----------------Get AID---------------------------
            var apdu = new CommandApdu(IsoCase.Case4Short, rfidReader.ActiveProtocol)
            {
                CLA  = 0x00,
                INS  = 0xA4,
                P1   = 0x04,
                P2   = 0x00,
                Le   = 0x00,
                Data = selectAid
            };

            var receivePci    = new SCardPCI();
            var sendPci       = SCardPCI.GetPci(rfidReader.ActiveProtocol);
            var receiveBuffer = new byte[256];
            var responseApdu  = new ResponseApdu(receiveBuffer, IsoCase.Case4Short, rfidReader.ActiveProtocol);


            String aid;

            byte[] aidByte = sendRequest(rfidReader, sc, receivePci, sendPci, apdu, responseApdu, IsoCase.Case4Short);

            if (aidByte == null)
            {
                return(null);
            }

            String pAid   = ByteArrayToHexString(aidByte);
            int    aidInd = pAid.LastIndexOf("4F07");

            aid = pAid.Substring(aidInd + 4, 14);

            //------------------------ end ------------------------------

            if (aid.Equals("A0000000041010"))
            {
                readRecord = selectMCAID;
                x          = 0x14;
            }
            else if (aid.Equals("A0000000031010"))
            {
                readRecord = selectVisaAID;
                x          = 0x1C;
            }

            //----------------selectMCAID---------------------------

            apdu = new CommandApdu(IsoCase.Case4Short, rfidReader.ActiveProtocol)
            {
                CLA  = 0x00,
                INS  = 0xA4,
                P1   = 0x04,
                P2   = 0x00,
                Le   = 0x00,
                Data = readRecord
            };

            byte[] selectTAypeCard = sendRequest(rfidReader, sc, receivePci, sendPci, apdu, responseApdu, IsoCase.Case4Short);
            if (selectTAypeCard == null)
            {
                return(null);
            }
            //------------------------ end ------------------------------

            apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.ActiveProtocol)
            {
                CLA = 0x00,
                INS = 0xB2,
                P1  = 0x01,
                P2  = x,
                Le  = 0x00
            };

            String pan;

            byte[] a = sendRequest(rfidReader, sc, receivePci, sendPci, apdu, responseApdu, IsoCase.Case2Short);   //(byte[])responseApdu.GetData();

            if (a == null)
            {
                return(null);
            }
            String p      = ByteArrayToHexString(a);
            int    panInd = p.LastIndexOf("5A08");

            pan = p.Substring(panInd + 4, 16);

            rfidReader.EndTransaction(SCardReaderDisposition.Leave);
            rfidReader.Disconnect(SCardReaderDisposition.Reset);

            return(pan);
        }
Esempio n. 14
0
        /// <summary>
        /// Will try to connect to _connectedReader and read the card.
        /// </summary>
        /// <returns>Either the data from the card or the error message. Or if 'uidOnly' is true, just the UID prefixed with 'UID^' and ending with '^'</returns>
        public string ReadCard(bool uidOnly = false)
        {
            SCardContext context = new SCardContext();

            context.Establish(SCardScope.System);
            SCardReader reader = new SCardReader(context);

            SCardError result = reader.Connect(_connectedReader, SCardShareMode.Shared, SCardProtocol.Any);

            if (result != SCardError.Success)
            {
                context.Dispose();
                reader.Dispose();
                return(string.Format("No card is detected (or reader reserved by another application){0}{1}",
                                     Environment.NewLine, SCardHelper.StringifyError(result)));
            }

            string[] readerNames; SCardProtocol protocol; SCardState state; byte[] atr;
            result = reader.Status(out readerNames, out state, out protocol, out atr);

            if (result != SCardError.Success)
            {
                context.Dispose();
                reader.Dispose();
                return(string.Format("Unable to read from card.{0}{1}", Environment.NewLine, SCardHelper.StringifyError(result)));
            }

            string message = string.Format("Card detected:{0}Protocol: {1}{0}State: {2}{0}ATR: {3}{0}",
                                           Environment.NewLine, protocol, state, BitConverter.ToString(atr ?? new byte[0]));

            CommandApdu apdu = new CommandApdu(IsoCase.Case2Short, reader.ActiveProtocol)
            {
                CLA         = 0xFF,
                Instruction = InstructionCode.GetData,
                P1          = 0x00,
                P2          = 0x00,
                Le          = 0
            };

            result = reader.BeginTransaction();

            if (result != SCardError.Success)
            {
                context.Dispose();
                reader.Dispose();
                return(string.Format("Cannot start transaction.{0} {1}", Environment.NewLine, SCardHelper.StringifyError(result)));
            }

            SCardPCI recievePci = new SCardPCI();
            IntPtr   sendPci    = SCardPCI.GetPci(reader.ActiveProtocol);

            byte[] recieveBuffer = new byte[256];

            result = reader.Transmit(sendPci, apdu.ToArray(), recievePci, ref recieveBuffer);

            if (result != SCardError.Success)
            {
                context.Dispose();
                reader.Dispose();
                return(string.Format("Cannot transmit data.{0} {1}", Environment.NewLine, SCardHelper.StringifyError(result)));
            }

            var responseApdu = new ResponseApdu(recieveBuffer, IsoCase.Case2Short, reader.ActiveProtocol);

            message += string.Format("SW1: {1}{0}SW2: {2}{0}", Environment.NewLine, responseApdu.SW1, responseApdu.SW2);

            string data = responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "--";

            if (uidOnly)
            {
                context.Dispose();
                reader.Dispose();
                return(string.Format("UID^{0}^", data));
            }

            message += string.Format("UID: {0}", data);

            reader.EndTransaction(SCardReaderDisposition.Leave);
            reader.Disconnect(SCardReaderDisposition.Reset);

            context.Dispose();
            reader.Dispose();
            return(message);
        }