Ejemplo 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");
        }
Ejemplo n.º 2
0
 /// <inheritdoc />
 public int Transmit(byte[] sendBuffer, byte[] receiveBuffer)
 {
     return(Transmit(
                sendPci: SCardPCI.GetPci(Protocol),
                sendBuffer: sendBuffer,
                receiveBuffer: receiveBuffer));
 }
        private static byte[] sendRequest(SCardReader rfidReader, SCardError sc, SCardPCI receivePci,
                                          IntPtr sendPci, CommandApdu apdu, ResponseApdu responseApdu, IsoCase isoCase)
        {
            sc = rfidReader.BeginTransaction();
            if (sc != SCardError.Success)
            {
                return(null);
            }

            receivePci = new SCardPCI();
            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)
            {
                return(null);
            }

            responseApdu = new ResponseApdu(receiveBuffer, isoCase, rfidReader.ActiveProtocol);

            if (!responseApdu.HasData)
            {
                return(null);
            }

            return((byte[])responseApdu.GetData());
        }
Ejemplo n.º 4
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 = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any)) {
                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.GetData,
                        P1          = 0x00,
                        P2          = 0x00,
                        Le          = 0 // We don't know the ID tag size
                    };

                    using (rfidReader.Transaction(SCardReaderDisposition.Leave)) {
                        Console.WriteLine("Retrieving the UID .... ");

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

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

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

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

                    Console.ReadKey();
                }
            }
        }
Ejemplo n.º 5
0
        /// <inheritdoc />
        public int Transmit(IntPtr sendPci, byte[] sendBuffer, int sendBufferLength, SCardPCI receivePci,
                            byte[] receiveBuffer,
                            int receiveBufferLength)
        {
            var receivePciPointer = receivePci?.MemoryPtr ?? IntPtr.Zero;

            return(Transmit(sendPci, sendBuffer, sendBufferLength, receivePciPointer, receiveBuffer,
                            receiveBufferLength));
        }
Ejemplo n.º 6
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();
        }
Ejemplo n.º 7
0
        /// <inheritdoc />
        public int Transmit(SCardPCI sendPci, byte[] sendBuffer, int sendBufferLength, byte[] receiveBuffer,
                            int receiveBufferLength)
        {
            ThrowOnInvalidSendPci(sendPci);

            var sendPciMemoryPtr = sendPci.MemoryPtr;

            return(Transmit(sendPciMemoryPtr, sendBuffer, sendBufferLength, IntPtr.Zero, receiveBuffer,
                            receiveBufferLength));
        }
Ejemplo n.º 8
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);
        }
Ejemplo n.º 9
0
        private static void ThrowOnInvalidSendPci(SCardPCI sendPci)
        {
            if (sendPci == null)
            {
                throw new ArgumentNullException(nameof(sendPci));
            }

            if (sendPci.MemoryPtr == IntPtr.Zero)
            {
                throw new ArgumentException("Valid sendPci required", nameof(sendPci));
            }
        }
Ejemplo n.º 10
0
        /// <inheritdoc />
        public int Transmit(SCardPCI sendPci, byte[] sendBuffer, int sendBufferLength, SCardPCI receivePci,
                            byte[] receiveBuffer,
                            int receiveBufferLength)
        {
            ThrowOnInvalidSendPci(sendPci);

            var sendPciPointer    = sendPci.MemoryPtr;
            var receivePciPointer = receivePci?.MemoryPtr ?? IntPtr.Zero;

            return(Transmit(sendPciPointer, sendBuffer, sendBufferLength, receivePciPointer, receiveBuffer,
                            receiveBufferLength));
        }
Ejemplo n.º 11
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);
 }
Ejemplo n.º 12
0
        /// <summary>
        /// Get data writing on the card
        /// </summary>
        /// <returns></returns>
        public static byte[] GetDataFromTheCard()
        {
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System))
            {
                var readerNames = context.GetReaders();
                if (readerNames == null)
                {
                    return(null);
                }

                var readerName = readerNames[0];
                if (readerName == null)
                {
                    return(null);
                }

                // 'using' statement to make sure the reader will be disposed (disconnected) on exit
                using (var rfidReader = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
                {
                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.ReadBinary,
                        P1          = 0x00,
                        P2          = 0x09,
                        Le          = 0x07 // We don't know the ID tag size
                    };

                    using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                    {
                        var sendPci    = SCardPCI.GetPci(rfidReader.Protocol);
                        var receivePci = new SCardPCI(); // IO returned protocol control information.

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

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

                        var responseApdu = new ResponseApdu(receiveBuffer, bytesReceived, IsoCase.Case2Short, rfidReader.Protocol);
                        return(responseApdu.GetData());
                    }
                }
            }
        }
Ejemplo n.º 13
0
        /// <inheritdoc />
        public int Transmit(SCardPCI sendPci, byte[] sendBuffer, byte[] receiveBuffer)
        {
            var sendBufferLength    = sendBuffer?.Length ?? 0;
            var receiveBufferLength = receiveBuffer?.Length ?? 0;

            return(Transmit(
                       sendPci: sendPci,
                       sendBuffer: sendBuffer,
                       sendBufferLength: sendBufferLength,
                       receivePci: default(SCardPCI),
                       receiveBuffer: receiveBuffer,
                       receiveBufferLength: receiveBufferLength));
        }
Ejemplo n.º 14
0
        private ResponseApdu RetransmitOnInsufficientBuffer(CommandApdu commandApdu, ResponseApdu responseApdu,
                                                            out SCardPCI receivePci)
        {
            int receiveBufferLength;
            var resendCmdApdu = (CommandApdu)commandApdu.Clone();

            if (responseApdu.SW2 == 0)
            {
                resendCmdApdu.Le    = 0;       // 256
                receiveBufferLength = 256 + 2; // 2 bytes for status word
            }
            else
            {
                resendCmdApdu.Le    = responseApdu.SW2;
                receiveBufferLength = responseApdu.SW2 + 2; // 2 bytes for status word
            }

            var receiveBuffer = new byte[receiveBufferLength];

            receivePci = new SCardPCI();

            try {
                var sendBuffer = resendCmdApdu.ToArray();

                // Shall we wait until we re-send we APDU/TPDU?
                if (RetransmitWaitTime > 0)
                {
                    Thread.Sleep(RetransmitWaitTime);
                }

                // send Command APDU again with new Le value
                return(SimpleTransmit(
                           sendBuffer,
                           sendBuffer.Length,
                           resendCmdApdu.Case,
                           resendCmdApdu.Protocol,
                           receivePci,
                           receiveBuffer,
                           receiveBufferLength));
            } catch (WinErrorInsufficientBufferException ex) {
                throw new InvalidApduException(
                          $"Retransmission failed because of unsufficient buffer. Le={resendCmdApdu.Le}", ex);
            } catch (InvalidOperationException ex) {
                throw new InvalidApduException(
                          $"Got SW1={responseApdu.SW1:X}. Retransmission failed because of an invalid APDU.",
                          resendCmdApdu, ex);
            }
        }
Ejemplo n.º 15
0
        public byte[] SendCommand2(byte[] command)
        {
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System))
            {
                using (var rfidReader = context.ConnectReader(CardReaderName, SCardShareMode.Shared, SCardProtocol.Any))
                {
                    using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                    {
                        Console.WriteLine("Retrieving the UID .... ");

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

                        var receiveBuffer = new byte[256];

                        command = new byte[] { 0, 132, 0, 0, 4 };
                        var bytesReceived = rfidReader.Transmit(
                            sendPci,               // Protocol Control Information (T0, T1 or Raw)
                            command,               // command APDU
                            command.Length,
                            receivePci,            // returning Protocol Control Information
                            receiveBuffer,
                            receiveBuffer.Length); // data buffer

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


                        byte[] receiveData = new byte[bytesReceived];

                        //byte[] result = responseApdu.GetData();

                        Array.Copy(receiveBuffer, receiveData, bytesReceived);

                        //  log?.AddLog("接收:" + BitConverter.ToString(receiveData));

                        return(receiveData);
                    }
                }
            }
        }
Ejemplo n.º 16
0
        private ResponseApdu SimpleTransmit(byte[] commandApdu, int commandApduLength, IsoCase isoCase,
                                            SCardProtocol protocol, SCardPCI receivePci, ref byte[] receiveBuffer, ref int receiveBufferLength)
        {
            SCardError sc;
            var        cmdSent = false;

            do
            {
                // send Command APDU to the card
                sc = _reader.Transmit(
                    SCardPCI.GetPci(_reader.ActiveProtocol),
                    commandApdu,
                    commandApduLength,
                    receivePci,
                    receiveBuffer,
                    ref receiveBufferLength);

                // Do we need to resend the command APDU?
                if (sc == SCardError.InsufficientBuffer &&
                    receiveBuffer.Length < receiveBufferLength)
                {
                    // The response buffer was too small.
                    receiveBuffer = new byte[receiveBufferLength];

                    // Shall we wait until we re-send we APDU?
                    if (RetransmitWaitTime > 0)
                    {
                        Thread.Sleep(RetransmitWaitTime);
                    }
                }
                else
                {
                    cmdSent = true;
                }
            } while (cmdSent == false);

            if (sc == SCardError.Success)
            {
                return(new ResponseApdu(receiveBuffer, receiveBufferLength, isoCase, protocol));
            }

            // An error occurred, throw exception..
            ThrowExceptionOnSCardError(sc);
            return(null);
        }
Ejemplo n.º 17
0
        private static string GetCardUID(string readerName)
        {
            using (var context = _contextFactory.Establish(SCardScope.System))
            {
                using (var rfidReader = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
                {
                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.GetData,
                        P1          = 0x00,
                        P2          = 0x00,
                        Le          = 0 // We don't know the ID tag size
                    };

                    using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                    {
                        //Console.WriteLine("Retrieving the UID .... ");

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

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

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

                        var responseApdu =
                            new ResponseApdu(receiveBuffer, bytesReceived, IsoCase.Case2Short, rfidReader.Protocol);
                        Log.Debug("Uid: {2} SW1: {0:X2}, SW2: {1:X2}\n",
                                  responseApdu.SW1,
                                  responseApdu.SW2,
                                  responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()) : "No uid received");
                        return(responseApdu.HasData ? BitConverter.ToString(responseApdu.GetData()).Replace("-", "").ToUpper() : null);
                    }
                }
            }
        }
Ejemplo n.º 18
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);
        }
Ejemplo n.º 19
0
        public byte[] SendCommand(byte[] command)
        {
            //  return SendCommand2(command);

            using (RfidReader.Transaction(SCardReaderDisposition.Leave))
            {
                CPUCardLogHelper.AddLog(LogTypeEnum.Send, "", command);

                var sendPci = SCardPCI.GetPci(RfidReader.Protocol);

                var receivePci = new SCardPCI(); // IO returned protocol control information.

                var receiveBuffer = new byte[256];
                try
                {
                    var bytesReceived = RfidReader.Transmit(
                        sendPci,               // Protocol Control Information (T0, T1 or Raw)
                        command,               // command APDU
                        command.Length,
                        receivePci,            // returning Protocol Control Information
                        receiveBuffer,
                        receiveBuffer.Length); // data buffer

                    //var responseApdu = new ResponseApdu(receiveBuffer, bytesReceived, IsoCase.Case2Short, rfidReader.Protocol);

                    byte[] receiveData = new byte[bytesReceived];

                    //byte[] result = responseApdu.GetData();

                    Array.Copy(receiveBuffer, receiveData, bytesReceived);

                    CPUCardLogHelper.AddLog(LogTypeEnum.Recivie, "", receiveData);

                    return(receiveData);
                }
                catch (Exception ex)
                {
                    CPUCardLogHelper.AddLog(LogTypeEnum.error, "设备发送异常" + ex.Message, command);
                    return(new byte[0]);
                }
            }
        }
Ejemplo n.º 20
0
        public IBinary Transmit(IBinary rawCommandApdu)
        {
            Debug.WriteLine("Read TreadID " + Thread.CurrentThread.ManagedThreadId);
            var receiveBuffer = new byte[1024 + _responseApduTrailerLength];
            var receivePci    = new SCardPCI();
            var sendPci       = SCardPCI.GetPci(SCardProtocol.T1);

            var sc = _reader.Transmit(
                sendPci,
                rawCommandApdu.Bytes(),
                receivePci,
                ref receiveBuffer
                );

            if (sc != SCardError.Success)
            {
                throw new Exception("Error: " + SCardHelper.StringifyError(sc));
            }
            return(new Binary(receiveBuffer));
        }
Ejemplo n.º 21
0
        private ResponseApdu SimpleTransmit(byte[] commandApdu, int commandApduLength, IsoCase isoCase,
                                            SCardProtocol protocol, SCardPCI receivePci, byte[] receiveBuffer, int receiveBufferLength)
        {
            SCardError sc;

            do
            {
                // send Command APDU to the card
                sc = Reader.Transmit(
                    SCardPCI.GetPci(Reader.ActiveProtocol),
                    commandApdu,
                    commandApduLength,
                    receivePci,
                    receiveBuffer,
                    ref receiveBufferLength);

                // Do we need to resend the command APDU?
                if (sc.HasInsufficientBuffer() && receiveBuffer.Length < receiveBufferLength)
                {
                    // The response buffer was too small.
                    receiveBuffer = new byte[receiveBufferLength];

                    // Shall we wait until we re-send we APDU?
                    if (RetransmitWaitTime > 0)
                    {
                        Thread.Sleep(RetransmitWaitTime);
                    }
                }
                else
                {
                    break;
                }
            } while (true);

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

            return(new ResponseApdu(receiveBuffer, receiveBufferLength, isoCase, protocol));
        }
Ejemplo n.º 22
0
        /// <summary>
        /// The implementation of transmit with log
        /// </summary>
        /// <param name="reader">Reader Name</param>
        /// <param name="command">APDU command</param>
        /// <returns></returns>
        public static Response TransmitWithLog(this IsoReader reader, CommandApdu command)
        {
            SCardPCI receivePci = new SCardPCI(); // IO returned protocol control information.
            IntPtr   sendPci    = SCardPCI.GetPci(reader.ActiveProtocol);



#if DEBUG
            System.Diagnostics.Debug.WriteLine(StringTools.ByteArrayToHexString(command.ToArray()));
#endif

            var res = reader.Transmit(command); // data buffer

#if DEBUG
            System.Diagnostics.Debug.WriteLine(StringTools.ByteArrayToHexString(res.GetData()));
#endif

            if (res.SW1 != 0x61)
            {
                return(res);
            }
            CommandApdu apdu2 = new CommandApdu(IsoCase.Case2Short, reader.ActiveProtocol)
            {
                CLA         = new ClassByte(ClaHighPart.Iso0x, SecureMessagingFormat.None, 0),
                Instruction = InstructionCode.GetResponse,
                P1          = 0x00,
                P2          = 00,
                Le          = res.SW2
            };

#if DEBUG
            System.Diagnostics.Debug.WriteLine(StringTools.ByteArrayToHexString(apdu2.ToArray()));
#endif
            res = reader.Transmit(apdu2);
#if DEBUG
            System.Diagnostics.Debug.WriteLine(StringTools.ByteArrayToHexString(res.GetData()));
#endif
            return(res);
        }
Ejemplo n.º 23
0
        /// <summary>
        /// 不要なものも含まれているので実装時は選別
        /// 現在は履歴を一件ずつ解析、表示しているが処理金額比較などを行う為
        /// データクラスを作成して、一度すべて読み込んでから解析を行う事
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_SuicaRead_Click(object sender, RoutedEventArgs e)
        {
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System))
            {
                var readerNames = context.GetReaders();
                if (NoReaderFound(readerNames))
                {
                    textBox_Log.Text += "You need at least one reader in order to run this example.\r\n";
                    return;
                }
                var readerName = ChooseRfidReader(readerNames);
                if (readerName == null)
                {
                    return;
                }

                using (var rfidReader = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
                {
                    byte[] dataIn         = { 0x0f, 0x09 };
                    var    apduSelectFile = new CommandApdu(IsoCase.Case4Short, rfidReader.Protocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.SelectFile,
                        P1          = 0x00,
                        P2          = 0x01,
                        Data        = dataIn,
                        Le          = 0
                    };
                    using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                    {
                        textBox_Log.Text += "SelectFile .... \r\n";

                        var sendPci       = SCardPCI.GetPci(rfidReader.Protocol);
                        var receivePci    = new SCardPCI();
                        var receiveBuffer = new byte[256];
                        var command       = apduSelectFile.ToArray();

                        var bytesReceivedSelectedFile = rfidReader.Transmit(sendPci, command, command.Length, receivePci, receiveBuffer, receiveBuffer.Length);
                        var responseApdu = new ResponseApdu(receiveBuffer, bytesReceivedSelectedFile, IsoCase.Case2Short, rfidReader.Protocol);

                        textBox_Log.Text += "SW1: " + responseApdu.SW1.ToString()
                                            + ", SW2: " + responseApdu.SW2.ToString() + "\r\n"
                                                                 + "Length: " + responseApdu.Length.ToString() + "\r\n";

                        for (int i = 0; i < 20; ++i)
                        {
                            var apduReadBinary = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                            {
                                CLA         = 0xFF,
                                Instruction = InstructionCode.ReadBinary,
                                P1          = 0x00,
                                P2          = (byte)i,
                                Le          = 0
                            };
                            textBox_Log.Text += "Read Binary .... \r\n";

                            var commandReadBinary = apduReadBinary.ToArray();

                            var bytesReceivedReadBinary2 =
                                rfidReader.Transmit(sendPci, commandReadBinary, commandReadBinary.Length, receivePci, receiveBuffer, receiveBuffer.Length);
                            var responseApdu2 = new ResponseApdu(receiveBuffer, bytesReceivedReadBinary2, IsoCase.Case2Extended, rfidReader.Protocol);

                            textBox_Log.Text += "SW1: " + responseApdu2.SW1.ToString()
                                                + ", SW2: " + responseApdu2.SW2.ToString()
                                                + "\r\n"
                                                + "Length: " + responseApdu2.Length.ToString() + "\r\n";

                            //parse_tag(receiveBuffer);
                            DataManager.GetInstance().AddHistryList(receiveBuffer);

                            textBox_Log.Text += "\r\n";
                        }
                        //履歴DB、CSVに書き込み
                        DataManager.GetInstance().WriteUserHistoryDB();
                        foreach (var s in DataManager.GetInstance().GetHistoryList())
                        {
                            ShowResultData(s);
                        }
                    }
                }
            }
            textBox_Log.Text += "-----------------------------------------------\r\n";
        }
Ejemplo n.º 24
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);
            }
        }
Ejemplo n.º 25
0
        static void Main(string[] args)
        {
            if (Process.GetProcesses().Count(
                    p => p.ProcessName.ToLower() ==
                    Path.GetFileNameWithoutExtension(AppDomain.CurrentDomain.SetupInformation.ApplicationName.ToLower())
                    ) > 1)
            {
                Console.WriteLine("Only a single instance can run in a time");
                return;
            }

            var    monitorFactory = MonitorFactory.Instance;
            var    monitor        = monitorFactory.Create(SCardScope.System);
            var    readerName     = "ACS ACR122 0";
            string cardUID        = null;

            monitor.StatusChanged += (sender, states) =>
            {
                if (states.NewState == SCRState.Empty)
                {
                    cardUID = null;
                    Console.Clear();
                    Console.WriteLine("[Status] Card Remove");
                }
                else if (states.NewState == SCRState.Present)
                {
                    if (states.NewState == SCRState.InUse)
                    {
                        Console.WriteLine($"[Status] {states.NewState}");
                        return;
                    }
                    Console.WriteLine($"[Status] {states.NewState}");

                    using (var context = ContextFactory.Instance.Establish(SCardScope.System))
                    {
                        try
                        {
                            if (!string.IsNullOrEmpty(cardUID))
                            {
                                return;
                            }
                            using (var rfidReader = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
                            {
                                var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                                {
                                    CLA         = 0xFF,
                                    Instruction = InstructionCode.GetData,
                                    P1          = 0x00,
                                    P2          = 0x00,
                                    Le          = 0
                                };

                                using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                                {
                                    //Console.WriteLine("Retrieving the UID .... ");

                                    var sendPci    = SCardPCI.GetPci(rfidReader.Protocol);
                                    var receivePci = new SCardPCI();

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

                                    var bytesReceived = rfidReader.Transmit(
                                        sendPci,
                                        command,
                                        command.Length,
                                        receivePci,
                                        receiveBuffer,
                                        receiveBuffer.Length);
                                    var responseApdu = new ResponseApdu(receiveBuffer, bytesReceived, IsoCase.Case2Short, rfidReader.Protocol);
                                    if (responseApdu.HasData)
                                    {
                                        cardUID = BitConverter.ToString(responseApdu.GetData()).Replace("-", string.Empty);
                                        string cardNo = CCardUtil.CardCode(cardUID);
                                        if (string.IsNullOrEmpty(cardNo))
                                        {
                                            Console.WriteLine("[Card] Unsupported Card");
                                            return;
                                        }
                                        Console.WriteLine("[Card] ID:" + cardNo);
                                        InputSimulator s = new InputSimulator();
                                        s.Keyboard.TextEntry(cardNo);
                                        Thread.Sleep(10);
                                        s.Keyboard.KeyDown(VirtualKeyCode.RETURN);
                                        Thread.Sleep(10);
                                        s.Keyboard.KeyUp(VirtualKeyCode.RETURN);
                                        Thread.Sleep(10);
                                    }
                                    else
                                    {
                                        cardUID = null;
                                        Console.WriteLine("[Card] No uid received");
                                    }
                                }
                            }
                        }
                        catch (PCSC.Exceptions.ReaderUnavailableException)
                        {
                            cardUID = null;
                            Console.WriteLine("[Card] Reader Unavailable");
                        }
                    }
                }
            };

            monitor.Start(readerName);

            Console.ReadKey();

            monitor.Cancel();
            monitor.Dispose();
        }
Ejemplo n.º 26
0
 /// <summary>Adds the specified PCI.</summary>
 /// <param name="receivePci">The PCI.</param>
 protected internal void Add(SCardPCI receivePci)
 {
     _lstReceivePci.Add(receivePci);
 }
Ejemplo n.º 27
0
        private byte[] send(byte[] apdu)
        {
            byte[] resp = new byte[290];

            SCardError rt;
            string     temp = "";

            Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Input,
                                                  new Action(() =>
            {
                temp = xTool.ConvertTool.Bytes2String(apdu);
                if (temp.Length > 9)
                {
                    print("-> " + temp.Substring(0, 4) + " " + temp.Substring(4, 4) + " " + temp.Substring(8, 2) + " " + temp.Substring(10));
                }
                else if (temp.Length > 7)
                {
                    print("-> " + temp.Substring(0, 4) + " " + temp.Substring(4, 4));
                }
                else
                {
                    print("-> " + temp);
                }
            }));
            if (temp.Length < 8)
            {
                throw new PCSCException(SCardError.ApduFormatWrong, "PCSC: 0x" + ((int)SCardError.ApduFormatWrong).ToString("X8") + ", " + getEnumDescription(SCardError.ApduFormatWrong));
            }

            var t1 = System.DateTime.Now;
            var t2 = t1;

            if (isDebug())
            {
                t1   = System.DateTime.Now;
                resp = this.debug.send(apdu);
                t2   = System.DateTime.Now;
            }
            else
            {
                t1 = System.DateTime.Now;
                rt = this.Reader.Transmit(SCardPCI.GetPci(this.Reader.ActiveProtocol), apdu, ref resp);
                t2 = System.DateTime.Now;
                if (rt != SCardError.Success)
                {
                    throw new PCSCException(rt, "PCSC: 0x" + ((int)rt).ToString("X8") + ", " + getEnumDescription(rt));
                }
                //throw new ArgumentException("Description: " + getEnumDescription(rt) + "\n" + "PCSC  Error: " + "0x" + ((int)rt).ToString("X8") + "\n");
            }

            Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Input,
                                                  new Action(() =>
            {
                print("<- " + xTool.ConvertTool.Bytes2String(resp));
                if (this.isTime)
                {
                    var tm = (t2.Hour * 60 * 60 + t2.Minute * 60 + t2.Second) * 1000 + t2.Millisecond - (t1.Hour * 60 * 60 + t1.Minute * 60 + t1.Second) * 1000 - t1.Millisecond;
                    print("Time: " + tm + "ms");
                }
            }));

            return(resp);
        }
Ejemplo n.º 28
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;
        }
Ejemplo n.º 29
0
        /// <summary>Transmits the specified command APDU.</summary>
        /// <param name="commandApdu">The command APDU.</param>
        /// <returns>A response containing one ore more <see cref="ResponseApdu" />.</returns>
        public virtual Response Transmit(CommandApdu commandApdu) {
            if (commandApdu == null) {
                throw new ArgumentNullException("commandApdu");
            }

            // prepare send buffer (Check Command APDU and convert it to an byte array)
            byte[] sendBuffer;
            try {
                sendBuffer = commandApdu.ToArray();
            } catch (InvalidOperationException exception) {
                throw new InvalidApduException("Invalid APDU.", commandApdu, exception);
            }

            // create Response object
            var response = new Response();

            // prepare receive buffer (Response APDU)
            var receiveBufferLength = commandApdu.ExpectedResponseLength; // expected size that shall be returned
            var receiveBuffer = new byte[receiveBufferLength];

            var receivePci = new SCardPCI();

            var responseApdu = SimpleTransmit(
                sendBuffer,
                sendBuffer.Length,
                commandApdu.Case, // ISO case used by the Command APDU
                commandApdu.Protocol, // Protocol used by the Command APDU
                receivePci,
                ref receiveBuffer,
                ref receiveBufferLength);

            /* Check status word SW1SW2:
             * 
             * 1. 0x6cxx -> Set response buffer size Le <- SW2
             * 2. AND/OR 0x61xx -> More data can be read with GET RESPONSE
             */

            if (responseApdu.SW1 == (byte) SW1Code.ErrorP3Incorrect) {
                // Case 1: SW1=0x6c, Previous Le/P3 not accepted -> Set le = SW2
                var resendCmdApdu = (CommandApdu) commandApdu.Clone();
                if (responseApdu.SW2 == 0) {
                    resendCmdApdu.Le = 0; // 256
                    receiveBufferLength = 256 + 2; // 2 bytes for status word
                } else {
                    resendCmdApdu.Le = responseApdu.SW2;
                    receiveBufferLength = responseApdu.SW2 + 2; // 2 bytes for status word
                }

                receiveBuffer = new byte[receiveBufferLength];
                receivePci = new SCardPCI();

                try {
                    sendBuffer = resendCmdApdu.ToArray();

                    // Shall we wait until we re-send we APDU/TPDU?
                    if (RetransmitWaitTime > 0) {
                        Thread.Sleep(RetransmitWaitTime);
                    }

                    // send Command APDU again with new Le value
                    responseApdu = SimpleTransmit(
                        sendBuffer,
                        sendBuffer.Length,
                        resendCmdApdu.Case,
                        resendCmdApdu.Protocol,
                        receivePci,
                        ref receiveBuffer,
                        ref receiveBufferLength);
                } catch (InvalidOperationException ex) {
                    throw new InvalidApduException("Got SW1=0x6c. Retransmission failed because of an invalid APDU.",
                        resendCmdApdu, ex);
                }
            }

            if (responseApdu.SW1 == (byte) SW1Code.NormalDataResponse) {
                // Case 2: SW1=0x61, More data available -> GET RESPONSE

                /* The transmission system shall issue a GET RESPONSE command APDU (or TPDU)
                 * to the card by assigning the minimum of SW2 and Le to parameter Le (or P3)). 
                 * Le = min(Le,SW2) 
                 */
                var le = (commandApdu.Le < responseApdu.SW2)
                    ? commandApdu.Le
                    : responseApdu.SW2;

                do {
                    // add the last ResponseAPDU to the Response object
                    response.Add(responseApdu);
                    response.Add(receivePci);

                    var getResponseApdu = ConstructGetResponseApdu(ref le);

                    if (le == 0) {
                        receiveBufferLength = 256 + 2; // 2 bytes for status word
                    } else {
                        receiveBufferLength = le + 2; // 2 bytes for status word
                    }

                    receiveBuffer = new byte[receiveBufferLength];

                    try {
                        sendBuffer = getResponseApdu.ToArray();

                        // Shall we wait until we re-send we APDU/TPDU?
                        if (RetransmitWaitTime > 0) {
                            Thread.Sleep(RetransmitWaitTime);
                        }

                        // send Command APDU again with new Le value
                        responseApdu = SimpleTransmit(
                            sendBuffer,
                            sendBuffer.Length,
                            getResponseApdu.Case,
                            getResponseApdu.Protocol,
                            receivePci,
                            ref receiveBuffer,
                            ref receiveBufferLength);
                    } catch (InvalidOperationException ex) {
                        throw new InvalidApduException(
                            "Got SW1=0x61. Retransmission failed because of an invalid GET RESPONSE APDU.",
                            getResponseApdu, ex);
                    }

                    // In case there is more data available.
                    le = responseApdu.SW2;
                } while (
                    // More data available.
                    responseApdu.SW1 == (byte) SW1Code.NormalDataResponse ||
                    // Warning condition: data may be corrupted. Iso7816-4 7.1.5
                    (responseApdu.SW1 == (byte) SW1Code.WarningNVDataNotChanged && responseApdu.SW2 == 0x81));
            }

            response.Add(responseApdu);
            response.Add(receivePci);

            return response;
        }
Ejemplo n.º 30
0
	    private ResponseApdu SimpleTransmit(byte[] commandApdu, int commandApduLength, IsoCase isoCase,
            SCardProtocol protocol, SCardPCI receivePci, ref byte[] receiveBuffer, ref int receiveBufferLength) {
            SCardError sc;
            var cmdSent = false;

            do {
                // send Command APDU to the card
                sc = _reader.Transmit(
                    SCardPCI.GetPci(_reader.ActiveProtocol),
                    commandApdu,
                    commandApduLength,
                    receivePci,
                    receiveBuffer,
                    ref receiveBufferLength);

                // Do we need to resend the command APDU?
                if (sc == SCardError.InsufficientBuffer &&
                    receiveBuffer.Length < receiveBufferLength) {
                    // The response buffer was too small. 
                    receiveBuffer = new byte[receiveBufferLength];

                    // Shall we wait until we re-send we APDU?
                    if (RetransmitWaitTime > 0) {
                        Thread.Sleep(RetransmitWaitTime);
                    }
                } else {
                    cmdSent = true;
                }
            } while (cmdSent == false);

            if (sc == SCardError.Success) {
                return new ResponseApdu(receiveBuffer, receiveBufferLength, isoCase, protocol);
            }

            // An error occurred, throw exception..
		    sc.Throw();
		    return null;
        }
Ejemplo n.º 31
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); }
        }
Ejemplo n.º 32
0
        private void Button_ReadID_Click(object sender, RoutedEventArgs e)
        {
            var contextFactory = ContextFactory.Instance;

            using (var context = contextFactory.Establish(SCardScope.System))
            {
                var readerNames = context.GetReaders();
                if (NoReaderFound(readerNames))
                {
                    textBox_Log.Text += "You need at least one reader in order to run this example." + "\r\n";
                    return;
                }

                var readerName = ChooseRfidReader(readerNames);

                if (readerName == null)
                {
                    return;
                }
                using (var rfidReader = context.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
                {
                    var apdu = new CommandApdu(IsoCase.Case2Short, rfidReader.Protocol)
                    {
                        CLA         = 0xFF,
                        Instruction = InstructionCode.GetData,
                        P1          = 0x00,
                        P2          = 0x00,
                        Le          = 0
                    };
                    using (rfidReader.Transaction(SCardReaderDisposition.Leave))
                    {
                        textBox_Log.Text += "Retrieving the UID .... " + "\r\n";

                        var sendPci       = SCardPCI.GetPci(rfidReader.Protocol);
                        var receivePci    = new SCardPCI();
                        var receiveBuffer = new byte[256];
                        var command       = apdu.ToArray();

                        var bytesReceived = rfidReader.Transmit(
                            sendPci,
                            command,
                            command.Length,
                            receivePci,
                            receiveBuffer,
                            receiveBuffer.Length);
                        var responseApdu = new ResponseApdu(receiveBuffer, bytesReceived, IsoCase.Case2Short, rfidReader.Protocol);

                        textBox_Log.Text += "SW1: " + responseApdu.SW1.ToString() + " ,SW2: " + responseApdu.SW2.ToString() + "\r\n";

                        if (responseApdu.HasData)
                        {
                            textBox_Log.Text += "Uid: " + BitConverter.ToString(responseApdu.GetData()) + "\r\n";
                        }
                        else
                        {
                            textBox_Log.Text += "Uid: No uid received" + "\r\n";
                        }
                    }
                }
            }
            textBox_Log.Text += "-----------------------------------------------\r\n";
        }