Merge branch 'Extract' into 'master'

Extract

See merge request fabinfra/fabaccess/nfc!1

NFC.sln

@@ -5,6 +5,14 @@ VisualStudioVersion = 16.0.30717.126
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NFC", "NFC\NFC.csproj", "{1D12BCDF-033F-40DE-ABA9-8BA5ABE0CA3A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NFC_PCSC", "NFC_PCSC\NFC_PCSC.csproj", "{62DE4EBC-6F35-4D31-8717-DBC62D46035C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NFC_Android", "NFC_Android\NFC_Android.csproj", "{B2609012-9D21-42F0-A2F9-3FE97D356392}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NFC_iOS", "NFC_iOS\NFC_iOS.csproj", "{C56A1E1A-976C-42ED-B7A2-08C6111AA0E8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NFC_Test", "NFC_Test\NFC_Test.csproj", "{FE8A1426-8B19-4CDF-A75E-80397E55BA95}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +23,22 @@ Global
 		{1D12BCDF-033F-40DE-ABA9-8BA5ABE0CA3A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1D12BCDF-033F-40DE-ABA9-8BA5ABE0CA3A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1D12BCDF-033F-40DE-ABA9-8BA5ABE0CA3A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{62DE4EBC-6F35-4D31-8717-DBC62D46035C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{62DE4EBC-6F35-4D31-8717-DBC62D46035C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{62DE4EBC-6F35-4D31-8717-DBC62D46035C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{62DE4EBC-6F35-4D31-8717-DBC62D46035C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B2609012-9D21-42F0-A2F9-3FE97D356392}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B2609012-9D21-42F0-A2F9-3FE97D356392}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B2609012-9D21-42F0-A2F9-3FE97D356392}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B2609012-9D21-42F0-A2F9-3FE97D356392}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C56A1E1A-976C-42ED-B7A2-08C6111AA0E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C56A1E1A-976C-42ED-B7A2-08C6111AA0E8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C56A1E1A-976C-42ED-B7A2-08C6111AA0E8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C56A1E1A-976C-42ED-B7A2-08C6111AA0E8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FE8A1426-8B19-4CDF-A75E-80397E55BA95}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FE8A1426-8B19-4CDF-A75E-80397E55BA95}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FE8A1426-8B19-4CDF-A75E-80397E55BA95}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FE8A1426-8B19-4CDF-A75E-80397E55BA95}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NFC/APDUCommand.cs

@@ -0,0 +1,149 @@
+using NFC.Helper;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NFC
+{
+    /// <summary>
+    /// Application Protocol Data Unit
+    /// https://de.wikipedia.org/wiki/Application_Protocol_Data_Unit
+    /// https://github.com/danm-de/pcsc-sharp/blob/246fc4303190184d6acd98a2d66f48cb7ffd7094/src/PCSC.Iso7816/CommandApdu.cs
+    /// </summary>
+    public class APDUCommand
+    {
+        #region Constructors
+        public APDUCommand(IsoCase isoCase, SCardProtocol sCardProtocol = SCardProtocol.ANY)
+        {
+            Case = isoCase;
+            Protocol = sCardProtocol;
+            Data = new byte[0];
+        }
+        #endregion
+
+        #region Properties
+        public IsoCase Case { get; set; }
+        public SCardProtocol Protocol { get; set; }
+
+        public byte CLA { get; set; } = 0x00;
+        public byte INS { get; set; } = 0x00;
+        public byte P1 { get; set; } = 0x00;
+        public byte P2 { get; set; } = 0x00;
+        public byte LC
+        {
+            get
+            {
+                return (byte)Data.Length;
+            }
+        }
+        public byte[] Data { get; set; }
+        public byte LE { get; set; } = 0x00;
+        #endregion
+
+        #region Methods
+        public byte[] ToArray()
+        {
+            byte[] header = ByteOperation.Concatenate(new byte[] { CLA }, new byte[] { INS }, new byte[] { P1 }, new byte[] { P2 });
+            switch (Case)
+            {
+                case IsoCase.Case1:
+                    /* Regarding to OpenSC: T0 needs one additional 
+                     * byte containing 0x00. */
+                    if (Protocol == SCardProtocol.T0)
+                    {
+                        return ByteOperation.Concatenate(header, new byte[] { 0x00 });
+                    }
+                    else
+                    {
+                        return header;
+                    }
+
+                case IsoCase.Case2Short:
+                    return ByteOperation.Concatenate(header, new byte[] { LE });
+
+                case IsoCase.Case3Short:
+                    return ByteOperation.Concatenate(header, new byte[] { LC }, Data);
+
+                case IsoCase.Case4Short:
+                    /* Regarding to OpenSC: T0 has no Le */
+                    if (Protocol == SCardProtocol.T0)
+                    {
+                        return ByteOperation.Concatenate(header, new byte[] { LC }, Data, new byte[] { 0x00 });
+                    }
+                    else
+                    {
+                        return ByteOperation.Concatenate(header, new byte[] { LC }, Data, new byte[] { LE });
+                    }
+
+                default:
+                    throw new NotSupportedException(string.Format("IsoCase {0} is not supported.", Case));
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is APDUCommand command &&
+                  Case == command.Case &&
+                  Protocol == command.Protocol &&
+                  CLA == command.CLA &&
+                  INS == command.INS &&
+                  P1 == command.P1 &&
+                  P2 == command.P2 &&
+                  Data.SequenceEqual(command.Data) &&
+                  LE == command.LE;
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = -98047210;
+            hashCode = hashCode * -1521134295 + Case.GetHashCode();
+            hashCode = hashCode * -1521134295 + Protocol.GetHashCode();
+            hashCode = hashCode * -1521134295 + CLA.GetHashCode();
+            hashCode = hashCode * -1521134295 + INS.GetHashCode();
+            hashCode = hashCode * -1521134295 + P1.GetHashCode();
+            hashCode = hashCode * -1521134295 + P2.GetHashCode();
+            hashCode = hashCode * -1521134295 + LC.GetHashCode();
+            hashCode = hashCode * -1521134295 + EqualityComparer<byte[]>.Default.GetHashCode(Data);
+            hashCode = hashCode * -1521134295 + LE.GetHashCode();
+            return hashCode;
+        }
+
+        public override string ToString()
+        {
+            string pattern_case1 = "(CASE: 1) CLA: 0x{0:x} | INS: 0x{1:x} | P1: 0x{2:x} | P2: 0x{3:x}";
+            string pattern_case2 = "(CASE: 2) CLA: 0x{0:x} | INS: 0x{1:x} | P1: 0x{2:x} | P2: 0x{3:x} | LE: 0x{4:x} |";
+            string pattern_case3 = "(CASE: 3) CLA: 0x{0:x} | INS: 0x{1:x} | P1: 0x{2:x} | P2: 0x{3:x} | LC: 0x{4:x} | Data: {5:x}";
+            string pattern_case4 = "(CASE: 4) CLA: 0x{0:x} | INS: 0x{1:x} | P1: 0x{2:x} | P2: 0x{3:x} | LC: 0x{4:x} | Data: {5:x} | LE: 0x{6:x} |";
+
+            switch (Case)
+            {
+                case IsoCase.Case1:
+                    return string.Format(pattern_case1, CLA, INS, P1, P2);
+                case IsoCase.Case2Short:
+                case IsoCase.Case2Extended:
+                    return string.Format(pattern_case2, CLA, INS, P1, P2, LE);
+                case IsoCase.Case3Short:
+                case IsoCase.Case3Extended:
+                    return string.Format(pattern_case3, CLA, INS, P1, P2, LC, BitConverter.ToString(Data).Replace("-", "").ToLower());
+                case IsoCase.Case4Short:
+                case IsoCase.Case4Extended:
+                    return string.Format(pattern_case4, CLA, INS, P1, P2, LC, BitConverter.ToString(Data).Replace("-", "").ToLower(), LE);
+                default:
+                    throw new Exception("Unknown IsoCase");
+            }
+        }
+        #endregion
+
+        #region Operator Overloading
+        public static bool operator ==(APDUCommand obj1, APDUCommand obj2)
+        {
+            return obj1.Equals(obj2);
+        }
+
+        public static bool operator !=(APDUCommand obj1, APDUCommand obj2)
+        {
+            return !(obj1.Equals(obj2));
+        }
+        #endregion
+    }
+}

NFC/APDUResponse.cs

@@ -0,0 +1,9 @@
+namespace NFC
+{
+    public class APDUResponse
+    {
+        public byte SW1 { get; set; }
+        public byte SW2 { get; set; }
+        public byte[] Body { get; set; }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/ChangeApplicationKey.cs

@@ -0,0 +1,21 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// hold the Access Rights for changing application keys (Change Key command)
+    /// </summary>
+    public enum ChangeApplicationKey : byte
+    {
+        /// <summary>
+        /// Application master key authentication is necessary to change any key (default)
+        /// </summary>
+        MASTERKEY = 0x00,
+        /// <summary>
+        /// Authentication with the key to be changed (same Key#) is necessary to change a key
+        /// </summary>
+        SAMEKEY = 0x0E,
+        /// <summary>
+        /// All keys (except application master key, see Bit 0) within this application are frozen
+        /// </summary>
+        ALLKEYS = 0x0F
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/ChangeMasterKey.cs

@@ -0,0 +1,18 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// codes whether the application master key is changeable
+    /// </summary>
+    public enum ChangeMasterKey : byte
+    {
+        /// <summary>
+        /// Application master key is not changeable anymore (frozen)
+        /// </summary>
+        FROZEN = 0x00,
+
+        /// <summary>
+        /// Application master key is changeable (authentication with the current application master key necessary, default)
+        /// </summary>
+        CHANGEABLE = 0x01,
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/ChangeMasterKeySettings.cs

@@ -0,0 +1,19 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// codes whether a change of the application master key settings is allowed
+    /// </summary>
+    public enum ChangeMasterKeySettings : byte
+    {
+
+        /// <summary>
+        /// configuration not changeable anymore (frozen)
+        /// </summary>
+        FROZEN = 0x00,
+
+        /// <summary>
+        /// this configuration is changeable if authenticated with the application master key (default)
+        /// </summary>
+        WITHMASTERKEY = 0x08
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/CreateDeleteFile.cs

@@ -0,0 +1,18 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// codes whether application master key authentication is needed before “Create File” / “Delete File”
+    /// </summary>
+    public enum CreateDeleteFile : byte
+    {
+        /// <summary>
+        /// “Create File”/ “Delete File”is permitted only with application master key authentication
+        /// </summary>
+        ONLYMASTERKEY = 0x00,
+
+        /// <summary>
+        /// “Create File”/ “Delete File”is permitted also without application master key authentication (default)
+        /// </summary>
+        NOKEY = 0x04,
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/CryptoOperationsType.cs

@@ -0,0 +1,12 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// Crypto method of the application
+    /// </summary>
+    public enum CryptoOperationsType : byte
+    {
+        TDES = 0x00,
+        TKTDES = 0x40,
+        AES = 0x80,
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/FileAccessRights.cs

@@ -0,0 +1,8 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    public enum FileAccessRights : byte
+    {
+        FREE = 0x0E,
+        NEVER = 0x0F
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/FileCommunication.cs

@@ -0,0 +1,20 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    public enum FileCommunication : byte
+    {
+        /// <summary>
+        /// "Plain communication"
+        /// </summary>
+        PLAIN = 0x00,
+
+        /// <summary>
+        /// Plain communication secured by DES/3DES MACing
+        /// </summary>
+        MAC = 0x01,
+
+        /// <summary>
+        /// Fully DES/3DES enciphered communication
+        /// </summary>
+        ENCRYPT = 0x03
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/FileDirectoryAccess.cs

@@ -0,0 +1,18 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// codes whether application master key authentication is needed for file directory access
+    /// </summary>
+    public enum FileDirectoryAccess : byte
+    {
+        /// <summary>
+        /// Successful application master key authentication is required for executing the “Get FID List”, “Get File Settings”and “Get Key Settings”commands
+        /// </summary>
+        ONLYMASTERKEY = 0x00,
+
+        /// <summary>
+        /// “Get FID List”, “Get File Settings” and “Get Key Settings” commands succeed independentlyof a preceding application master key authentication (default)
+        /// </summary>
+        NOKEY = 0x02,
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/FileIdentifies.cs

@@ -0,0 +1,11 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    /// <summary>
+    /// Indicates use of 2 byte ISO/IEC 7816-4 File Identifies for files within the Application
+    /// </summary>
+    public enum FileIdentifies : byte
+    {
+        NOTUSED = 0x00,
+        USED = 0x20
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Enums/FileTypes.cs

@@ -0,0 +1,30 @@
+namespace NFC.Cards.NXP_MIFARE_DESFire.Enums
+{
+    enum FileTypes : byte
+    {
+        /// <summary>
+        /// Standard Data File
+        /// </summary>
+        STANDARD =  0x00,
+
+        /// <summary>
+        /// Backup Data Files
+        /// </summary>
+        BACKUP = 0x01,
+
+        /// <summary>
+        /// Value Files with Backup
+        /// </summary>
+        VALUE = 0x02,
+
+        /// <summary>
+        /// Linear Record Files with Backup
+        /// </summary>
+        LINEARRECORD = 0x03,
+
+        /// <summary>
+        /// Cyclic Record Files with Backup
+        /// </summary>
+        CYCLICRECORD = 0x04
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/AuthenticationDelayException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Currently not allowed to authenticate. Keeptrying until full delay is spent.
+    /// 0x91AD
+    /// </summary>
+    public class AuthenticationDelayException : Exception
+    {
+        public AuthenticationDelayException()
+        {
+
+        }
+
+        public AuthenticationDelayException(string message) : base(message)
+        {
+
+        }
+
+        public AuthenticationDelayException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/AuthenticationErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Current authentication status does not allow there- quested command.
+    /// 0x91AE
+    /// </summary>
+    public class AuthenticationErrorException : Exception
+    {
+        public AuthenticationErrorException()
+        {
+
+        }
+
+        public AuthenticationErrorException(string message) : base(message)
+        {
+
+        }
+
+        public AuthenticationErrorException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/AuthenticationMissingException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Current authentication status does not allow there- quested command.
+    /// 0x91AE
+    /// </summary>
+    public class AuthenticationMissingException : Exception
+    {
+        public AuthenticationMissingException()
+        {
+
+        }
+
+        public AuthenticationMissingException(string message) : base(message)
+        {
+
+        }
+
+        public AuthenticationMissingException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/BoundaryErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Attempt toread/write data from/to beyond thefile’s/record’s limits. Attempt to exceed the limitsof a value file.
+    /// 0x91BE
+    /// </summary>
+    public class BoundaryErrorException : Exception
+    {
+        public BoundaryErrorException()
+        {
+
+        }
+
+        public BoundaryErrorException(string message) : base(message)
+        {
+
+        }
+
+        public BoundaryErrorException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/CommandAbortedException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Previous Command was not fully completed.Not all Frames were requested or provided bythe PCD.
+    /// 0x91CA
+    /// </summary>
+    public class CommandAbortedException : Exception
+    {
+        public CommandAbortedException()
+        {
+
+        }
+
+        public CommandAbortedException(string message) : base(message)
+        {
+
+        }
+
+        public CommandAbortedException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/DuplicateErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Creation of file/application failed because file/application with same number already exists
+    /// 0x91DE
+    /// </summary>
+    public class DuplicateErrorException : Exception
+    {
+        public DuplicateErrorException()
+        {
+
+        }
+
+        public DuplicateErrorException(string message) : base(message)
+        {
+
+        }
+
+        public DuplicateErrorException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/FileNotFoundException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Specified file number does not exist.
+    /// 0x91F0
+    /// </summary>
+    public class FileNotFoundException : Exception
+    {
+        public FileNotFoundException()
+        {
+
+        }
+
+        public FileNotFoundException(string message) : base(message)
+        {
+
+        }
+
+        public FileNotFoundException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/IllegalCommandCodeException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Command code not supported.
+    /// 0x911C
+    /// </summary>
+    public class IllegalCommandCodeException : Exception
+    {
+        public IllegalCommandCodeException()
+        {
+
+        }
+
+        public IllegalCommandCodeException(string message) : base(message)
+        {
+
+        }
+
+        public IllegalCommandCodeException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/IntegrityErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// CRC or MAC does not match data. Paddingbytes not valid.
+    /// 0x911E
+    /// </summary>
+    public class IntegrityErrorException : Exception
+    {
+        public IntegrityErrorException()
+        {
+
+        }
+
+        public IntegrityErrorException(string message) : base(message)
+        {
+
+        }
+
+        public IntegrityErrorException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/LengthErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Length of command string invalid.
+    /// 0x917E
+    /// </summary>
+    public class LengthErrorException : Exception
+    {
+        public LengthErrorException()
+        {
+
+        }
+
+        public LengthErrorException(string message) : base(message)
+        {
+
+        }
+
+        public LengthErrorException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/NoSuchKeyException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Invalid key number specified.
+    /// 0x9140
+    /// </summary>
+    public class NoSuchKeyException : Exception
+    {
+        public NoSuchKeyException()
+        {
+
+        }
+
+        public NoSuchKeyException(string message) : base(message)
+        {
+
+        }
+
+        public NoSuchKeyException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/ParameterErrorException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Value of the parameter(s) invalid.
+    /// 0x919E
+    /// </summary>
+    public class ParameterErrorException : Exception
+    {
+        public ParameterErrorException()
+        {
+
+        }
+
+        public ParameterErrorException(string message) : base(message)
+        {
+
+        }
+
+        public ParameterErrorException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/Exceptions/PermissionDeniedException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire.Exceptions
+{
+    /// <summary>
+    /// Current configuration / status does not allow the requested command.
+    /// 0x919D
+    /// </summary>
+    public class PermissionDeniedException : Exception
+    {
+        public PermissionDeniedException()
+        {
+
+        }
+
+        public PermissionDeniedException(string message) : base(message)
+        {
+
+        }
+
+        public PermissionDeniedException(string message, Exception inner) : base(message, inner)
+        {
+
+        }
+    }
+}

NFC/Cards/NXP MIFARE DESFire/NXP_MIFARE_DESFire.cs

@@ -0,0 +1,893 @@
+using log4net;
+using NFC.Cards.NXP_MIFARE_DESFire.Enums;
+using NFC.Cards.NXP_MIFARE_DESFire.Exceptions;
+using NFC.Helper;
+using NFC.Helper.Crypto.Cipher;
+using NFC.Helper.Crypto.CRC;
+using NFC.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NFC.Cards.NXP_MIFARE_DESFire
+{
+    public class NXP_MIFARE_DESFire
+    {
+        // Docs https://hackmd.io/qATu8uYdRnOC40aFrB9afg
+
+        #region Log
+        private static readonly ILog _Log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        #endregion
+
+        #region Contructors
+        /// <summary>
+        /// Construct MIFRARE_DESFire Object with ICard Interface
+        /// </summary>
+        /// <param name="card">Implementation of ICard, only transmit is used</param>
+        public NXP_MIFARE_DESFire(ICard card)
+        {
+            _Card = card;
+        }
+        #endregion
+
+        #region Properties
+        /// <summary>
+        /// ICard Implementation used to transmit APDUCommands and recive APDUResponses
+        /// </summary>
+        private readonly ICard _Card;
+
+        /// <summary>
+        /// SessionKey, is set after Successfull Authentication
+        /// </summary>
+        public byte[] _SessionKey;
+
+        /// <summary>
+        /// Initialation Vector for CBC Encryption
+        /// Is 0 bytes after Successfull Authentication
+        /// </summary>
+        public byte[] _IV;
+        #endregion
+
+        #region Methods
+        #region Helper Methods
+        /// <summary>
+        /// Check APDU Response for DESFire Error Codes
+        /// https://www.nxp.com/docs/en/data-sheet/MF2DLHX0.pdf
+        /// Section: 11.3
+        /// </summary>
+        public void CheckAPDUResponse(APDUResponse response)
+        {
+            if (response == null)
+            {
+                throw new ArgumentNullException("Response cannot be null.");
+            }
+
+            if (response.SW1 == 0x91)
+            {
+                switch (response.SW2)
+                {
+                    case 0x00: // OPERATION_OK
+                        return;
+                    case 0x0C: // NO_CHANGES
+                        return;
+                    case 0x1C: // ILLEGAL_COMMAND_CODE
+                        throw new IllegalCommandCodeException();
+                    case 0x1E: // INTEGRITY_ERROR
+                        throw new IntegrityErrorException();
+                    case 0x40: // NO_SUCH_KEY
+                        throw new NoSuchKeyException();
+                    case 0x7E: // LENGTH_ERROR
+                        throw new LengthErrorException();
+                    case 0x9D: // PERMISSION_DENIED
+                        throw new PermissionDeniedException();
+                    case 0x9E: // PARAMETER_ERROR
+                        throw new ParameterErrorException();
+                    case 0xAD: // AUTHENTICATION_DELAY
+                        throw new AuthenticationDelayException();
+                    case 0xAE: // AUTHENTICATION_ERROR
+                        throw new AuthenticationErrorException();
+                    case 0xAF: // ADDITIONAL_FRAME
+                        return;
+                    case 0xBE: // BOUNDARY_ERROR
+                        throw new BoundaryErrorException();
+                    case 0xCA: // COMMAND_ABORTED
+                        throw new CommandAbortedException();
+                    case 0xDE: // DUPLICATE_ERROR
+                        throw new DuplicateErrorException();
+                    case 0xF0: // FILE_NOT_FOUND
+                        throw new FileNotFoundException();
+                    default:
+                        break;
+                }
+            }
+
+            throw new Exception(string.Format("Unknown Response Code: 0x{0}.", BitConverter.ToString(new byte[] { response.SW1, response.SW2 }).Replace("-", string.Empty)));
+        }
+        #endregion
+
+        #region Crypto Operation
+        /// <summary>
+        /// Generates SessionKey for DES Authentification
+        /// </summary>
+        /// <returns>16Byte SessionKey</returns>
+        public byte[] GenerateSesionKey_DES(byte[] rndA, byte[] rndB)
+        {
+            byte[] sesssionkey = new byte[8];
+
+            for (int i = 0; i < sesssionkey.Length; i++)
+            {
+                if (i < 4)
+                {
+                    sesssionkey[i] = rndA[i];
+                }
+                else
+                {
+                    sesssionkey[i] = rndB[i - 4];
+                }
+            }
+
+            // DES SessionKey is a double DES Key
+            return ByteOperation.Concatenate(sesssionkey, sesssionkey);
+        }
+
+        /// <summary>
+        /// Generates SessionKey for AES Authentification
+        /// </summary>
+        /// <returns>16Byte SessionKey</returns>
+        public byte[] GenerateSesionKey_AES(byte[] rndA, byte[] rndB)
+        {
+            byte[] sesssionkey = new byte[16];
+
+            for (int i = 0; i < sesssionkey.Length; i++)
+            {
+                if (i < 4)
+                {
+                    sesssionkey[i] = rndA[i];
+                }
+                else if (i >= 4 && i < 8)
+                {
+                    sesssionkey[i] = rndB[i - 4];
+                }
+                else if (i >= 8 && i < 12)
+                {
+                    sesssionkey[i] = rndA[i + 4];
+                }
+                else
+                {
+                    sesssionkey[i] = rndB[i];
+                }
+            }
+
+            return sesssionkey;
+        }
+        #endregion
+
+        #region Configuration Generator
+        /// <summary>
+        /// Genearte KeySetting1 for Application Settings or PICC Setting
+        /// </summary>
+        public byte GenerateKeySetting1(ChangeApplicationKey changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
+        {
+            return (byte)(((byte)changeKey << 4) | (byte)changeMasterKeySettings | (byte)createDeleteFile | (byte)fileDirectoryAccess | (byte)changeMasterKey);
+        }
+
+        /// <summary>
+        /// Genearte KeySetting1 for Application Settings or PICC Setting
+        /// </summary>
+        /// <param name="changeKey">ID of Key for changing Application Keys</param>
+        /// <returns></returns>
+        public byte GenerateKeySetting1(byte changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
+        {
+            if (changeKey < 0x01 || changeKey >= 0x0E)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            return GenerateKeySetting1((ChangeApplicationKey)changeKey, changeMasterKeySettings, createDeleteFile, fileDirectoryAccess, changeMasterKey);
+        }
+
+        /// <summary>
+        /// Genearte KeySetting2 for Application Creation
+        /// </summary>
+        /// <param name="numberOfKeys">Number of keys that can be stored within the application (0x01-0x0D)</param>
+        /// <returns></returns>
+        public byte GenerateKeySetting2(CryptoOperationsType cryptoOperations, FileIdentifies fileIdentifies, byte numberOfKeys)
+        {
+            if (numberOfKeys < 0x01 || numberOfKeys >= 0x0D)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+
+            return (byte)((byte)cryptoOperations | (byte)fileIdentifies | numberOfKeys);
+        }
+
+        /// <summary>
+        /// Generate FileAccess Rights for File Settings
+        /// Use enum AccesRights for Free or Never Option
+        /// </summary>
+        /// <param name="read">KeyID for Read Access</param>
+        /// <param name="write">KeyID for Write Access</param>
+        /// <param name="read_write">KeyID for Read and Write Access</param>
+        /// <param name="configure">KeyID for Configuration Access</param>
+        public UInt16 GenerateFileAccessRights(byte read, byte write, byte read_write, byte configure)
+        {
+            if (read > 0x0F || write > 0x0F || read_write > 0x0F || configure > 0x0F)
+            {
+                throw new ArgumentOutOfRangeException("One KeyID is not valid");
+            }
+
+            return (UInt16)((read << 12) | (write << 8) | (read_write << 4) | configure);
+        }
+        #endregion
+
+        #region DESFire Commands
+        /// <summary>
+        /// Select Application by ApplicationID (AID)
+        /// </summary>
+        /// <param name="aid">3 Byte AID</param>
+        public void SelectApplication(UInt32 aid)
+        {
+            if (aid > 0xFFFFFF)
+            {
+                throw new ArgumentOutOfRangeException("AID is too large");
+            }
+
+            byte[] id_byte = BitConverter.GetBytes(aid);
+            _Log.InfoFormat("Select Application: {0}", HexConverter.ConvertToHexString(id_byte.ToArray()));
+
+            APDUCommand cmd_SelectApplication = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0x5A,
+                Data = new byte[]
+                {
+                    id_byte[0],
+                    id_byte[1],
+                    id_byte[2]
+                }
+            };
+            _Log.Debug(cmd_SelectApplication.ToString());
+            HexConverter.ConvertToHexString(cmd_SelectApplication.ToArray());
+            APDUResponse response = _Card.Transmit(cmd_SelectApplication);
+            _Log.DebugFormat(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Authenticate to PICC, with ISO Authenticate for DES Key
+        /// </summary>
+        /// <param name="key_id">0x01 - 0x0D</param>
+        /// <param name="key">Array of 8/16 Bytes</param>
+        /// <param name="rndA">!!! WARNING For Testing only !!!</param>
+        public void AuthenticateISO_DES(byte key_id, byte[] key, byte[] rndA = null)
+        {
+            if (key_id >= 0x0E)
+            {
+                throw new ArgumentOutOfRangeException("KeyID is invalid");
+            }
+
+            _Log.InfoFormat("Authenticate with DES Key No: 0x{0:x}", key_id);
+
+            // Sepearte Initialisation Vector for Authentication Process
+            byte[] iv = new byte[8];
+
+            APDUCommand cmd_challange_request = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0x1A,
+                Data = new byte[]
+                {
+                    key_id
+                }
+            };
+            _Log.Debug(cmd_challange_request.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_challange_request);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+
+            byte[] rndB_enc = response.Body;
+            _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_enc));
+
+            TDES des = new TDES();
+            byte[] rndB = des.Decrypt(rndB_enc, key, ByteOperation.GenerateEmptyArray(8));
+            _Log.DebugFormat("rndB: {0}", HexConverter.ConvertToHexString(rndB));
+
+            rndB.CopyTo(iv, 0);
+
+            byte[] rndB_rl = ByteOperation.RotateLeft(rndB);
+            _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_rl));
+
+            if (rndA == null)
+            {
+                Random rnd = new Random();
+                rndA = new byte[8];
+                rnd.NextBytes(rndA);
+            }
+            _Log.DebugFormat("rndA: {0}", HexConverter.ConvertToHexString(rndA));
+
+            byte[] rndAB = ByteOperation.Concatenate(rndA, rndB_rl);
+            _Log.DebugFormat("rndAB: {0}", HexConverter.ConvertToHexString(rndAB));
+
+            byte[] rndAB_enc = des.Encrypt(rndAB, key, rndB_enc);
+            _Log.DebugFormat("rndAB_enc: {0}", HexConverter.ConvertToHexString(rndAB_enc));
+            iv = ByteOperation.ExtractLastBlock(rndAB_enc, 8);
+
+            APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAF,
+                Data = rndAB_enc
+            };
+            _Log.Debug(cmd_challange_response.ToString());
+
+            response = _Card.Transmit(cmd_challange_response);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+
+            byte[] encryptedRndAFromCard = response.Body;
+            _Log.DebugFormat("encryptedRndAFromCard: {0}", HexConverter.ConvertToHexString(encryptedRndAFromCard));
+
+            byte[] rotatedRndAFromCard = des.Decrypt(encryptedRndAFromCard, key, iv);
+            _Log.DebugFormat("rotatedRndAFromCard: {0}", HexConverter.ConvertToHexString(rotatedRndAFromCard));
+
+            byte[] rndAFromCard = ByteOperation.RotateRight(rotatedRndAFromCard);
+            _Log.DebugFormat("rndAFromCard: {0}", HexConverter.ConvertToHexString(rndAFromCard));
+
+            if (!rndA.SequenceEqual(rndAFromCard))
+            {
+                throw new Exception("Authentication failed, PICC Challenge is invalid.");
+            }
+
+            _Log.Info("Authenticated");
+
+            _SessionKey = GenerateSesionKey_DES(rndA, rndB);
+            _Log.DebugFormat("SessionKey: {0}", HexConverter.ConvertToHexString(_SessionKey));
+
+            _IV = ByteOperation.GenerateEmptyArray(8);
+            _Log.DebugFormat("IV: {0}", HexConverter.ConvertToHexString(_IV));
+        }
+
+        /// <summary>
+        /// Format PICC
+        /// Need Authentication for PICC / Application 0x000000
+        /// </summary>
+        public void Format()
+        {
+            _Log.Info("Format PICC");
+
+            APDUCommand cmd_format = new APDUCommand(IsoCase.Case2Short)
+            {
+                CLA = 0x90,
+                INS = 0xFC,
+            };
+            _Log.Debug(cmd_format.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_format);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Create Application for ApplicationID
+        /// </summary>
+        /// <param name="aid">3 Byte ID</param>
+        public void CreateApplication(UInt32 aid, byte keysetting1, byte keysetting2)
+        {
+            if (aid > 0xFFFFFF)
+            {
+                throw new ArgumentOutOfRangeException("AID is too large");
+            }
+
+            byte[] id_byte = BitConverter.GetBytes(aid);
+            _Log.InfoFormat("Create Application: {0}", HexConverter.ConvertToHexString(id_byte.ToArray()));
+
+            APDUCommand cmd_CreateApplication = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xCA,
+                Data = new byte[]
+                {
+                    id_byte[0],
+                    id_byte[1],
+                    id_byte[2],
+                    keysetting1,
+                    keysetting2
+                }
+            };
+            _Log.Debug(cmd_CreateApplication.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_CreateApplication);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Authenticate to PICC, with ISO Authenticate
+        /// </summary>
+        /// <param name="key_id">0x01 - 0x0D</param>
+        /// <param name="key">Array of 16 Bytes</param>
+        /// <param name="rndA">!!! WARNING For Testing only !!!</param>
+        public void AuthenticateISO_AES(byte key_id, byte[] key, byte[] rndA = null)
+        {
+            if (key_id >= 0x0E)
+            {
+                throw new ArgumentOutOfRangeException("KeyID is invalid");
+            }
+
+            _Log.InfoFormat("Authenticate with AES Key No: 0x{0:x}", key_id);
+
+            // Sepearte InitialisationVector for Authentication
+            byte[] iv = new byte[16];
+
+            APDUCommand cmd_challange_request = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAA,
+                Data = new byte[]
+                {
+                    key_id
+                }
+            };
+            _Log.Debug(cmd_challange_request.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_challange_request);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+
+            byte[] rndB_enc = response.Body;
+            _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_enc));
+
+            AES aes = new AES();
+            byte[] rndB = aes.Decrypt(rndB_enc, key, ByteOperation.GenerateEmptyArray(16));
+            _Log.DebugFormat("rndB: {0}", HexConverter.ConvertToHexString(rndB));
+
+            rndB.CopyTo(iv, 0);
+
+            byte[] rndB_rl = ByteOperation.RotateLeft(rndB);
+            _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_rl));
+
+            if (rndA == null)
+            {
+                Random rnd = new Random();
+                rndA = new byte[16];
+                rnd.NextBytes(rndA);
+            }
+            _Log.DebugFormat("rndA: {0}", HexConverter.ConvertToHexString(rndA));
+
+            byte[] rndAB = ByteOperation.Concatenate(rndA, rndB_rl);
+            _Log.DebugFormat("rndAB: {0}", HexConverter.ConvertToHexString(rndAB));
+
+            byte[] rndAB_enc = aes.Encrypt(rndAB, key, rndB_enc);
+            _Log.DebugFormat("rndAB_enc: {0}", HexConverter.ConvertToHexString(rndAB_enc));
+            iv = ByteOperation.ExtractLastBlock(rndAB_enc, 16);
+
+            APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAF,
+                Data = rndAB_enc
+            };
+            _Log.Debug(cmd_challange_response.ToString());
+
+            response = _Card.Transmit(cmd_challange_response);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+
+            byte[] encryptedRndAFromCard = response.Body;
+            _Log.DebugFormat("encryptedRndAFromCard: {0}", HexConverter.ConvertToHexString(encryptedRndAFromCard));
+
+            byte[] rotatedRndAFromCard = aes.Decrypt(encryptedRndAFromCard, key, iv);
+            _Log.DebugFormat("rotatedRndAFromCard: {0}", HexConverter.ConvertToHexString(rotatedRndAFromCard));
+
+            byte[] rndAFromCard = ByteOperation.RotateRight(rotatedRndAFromCard);
+            _Log.DebugFormat("rndAFromCard: {0}", HexConverter.ConvertToHexString(rndAFromCard));
+
+            if (!rndA.SequenceEqual(rndAFromCard))
+            {
+                throw new Exception("Authentication failed, PICC Challenge is invalid.");
+            }
+
+            _SessionKey = GenerateSesionKey_AES(rndA, rndB);
+            _Log.DebugFormat("SessionKey: {0}", HexConverter.ConvertToHexString(_SessionKey));
+
+            _IV = ByteOperation.GenerateEmptyArray(16);
+            _Log.DebugFormat("IV: {0}", HexConverter.ConvertToHexString(_IV));
+        }
+
+        /// <summary>
+        /// Change AES key, the same as Authenticated 
+        /// </summary>
+        /// <param name="key_id">0x01 - 0x0D</param>
+        /// <param name="new_key">Array of 16 Bytes</param>
+        /// <param name="key_version">Version of Key(min. 0x10)</param>
+        public void ChangeKey_AES(byte key_id, byte[] new_key, byte key_version)
+        {
+            if (key_id >= 0x0E)
+            {
+                throw new ArgumentOutOfRangeException("KeyID is invalid");
+            }
+
+            _Log.InfoFormat("Change AES Key No: 0x{0:x}", key_id);
+
+            byte[] header = new byte[]
+            {
+                0xC4, key_id
+            };
+            _Log.DebugFormat("header: {0}", HexConverter.ConvertToHexString(header));
+
+            // AES Key Version is Append to Key
+            byte[] key_and_version = ByteOperation.Concatenate(new_key, new byte[] { key_version });
+            byte[] command = ByteOperation.Concatenate(header, key_and_version);
+            _Log.DebugFormat("command: {0}", HexConverter.ConvertToHexString(command));
+
+            CRC32 crc32 = new CRC32();
+            byte[] crc = crc32.Calculate(command);
+            _Log.DebugFormat("crc: {0}", HexConverter.ConvertToHexString(crc));
+
+            byte[] cryptogram = ByteOperation.Concatenate(key_and_version, crc);
+            _Log.DebugFormat("cryptogram: {0}", HexConverter.ConvertToHexString(cryptogram));
+
+            byte[] cryptogram_block = ByteOperation.ExpandToBlockSize(cryptogram, 16);
+            _Log.DebugFormat("cryptogram_block: {0}", HexConverter.ConvertToHexString(cryptogram_block));
+
+            AES aes = new AES();
+            byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
+            _Log.DebugFormat("cryptogram_enc: {0}", HexConverter.ConvertToHexString(cryptogram_enc));
+
+            _IV = ByteOperation.ExtractLastBlock(cryptogram_enc, 16);
+            _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
+
+            byte[] data = ByteOperation.Concatenate(new byte[] { key_id }, cryptogram_enc);
+            _Log.DebugFormat("data: {0}", HexConverter.ConvertToHexString(data));
+
+            APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xC4,
+                Data = data
+            };
+            _Log.Debug(cmd_ChangeKey.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_ChangeKey);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Change AES key, other than Authenticated 
+        /// </summary>
+        /// <param name="key_id">0x01 - 0x0D</param>
+        /// <param name="new_key">Array of 16 Bytes</param>
+        /// <param name="key_version">Version of Key(min. 0x10)</param>
+        public void ChangeOtherKey_AES(byte key_id, byte[] new_key, byte[] old_key, byte key_version)
+        {
+            if (key_id >= 0x0E)
+            {
+                throw new ArgumentOutOfRangeException("KeyID is invalid");
+            }
+
+            _Log.InfoFormat("Change AES Key No: 0x{0:x}", key_id);
+
+            byte[] header = new byte[]
+            {
+                0xC4, key_id
+            };
+            _Log.DebugFormat("header: {0}", HexConverter.ConvertToHexString(header));
+
+            byte[] key_xor = ByteOperation.XOR(new_key, old_key);
+
+            // AES Key Version is Append to Key
+            byte[] key_and_version = ByteOperation.Concatenate(key_xor, new byte[] { key_version });
+            byte[] command = ByteOperation.Concatenate(header, key_and_version);
+            _Log.DebugFormat("command: {0}", HexConverter.ConvertToHexString(command));
+
+            CRC32 crc32 = new CRC32();
+            byte[] crc_cmd = crc32.Calculate(command);
+            _Log.DebugFormat("crc_cmd: {0}", HexConverter.ConvertToHexString(crc_cmd));
+            byte[] crc_key = crc32.Calculate(new_key);
+            _Log.DebugFormat("crc_key: {0}", HexConverter.ConvertToHexString(crc_key));
+
+            byte[] cryptogram = ByteOperation.Concatenate(key_and_version, crc_cmd);
+            cryptogram = ByteOperation.Concatenate(cryptogram, crc_key);
+            _Log.DebugFormat("cryptogram: {0}", HexConverter.ConvertToHexString(cryptogram));
+
+            byte[] cryptogram_block = ByteOperation.ExpandToBlockSize(cryptogram, 16);
+            _Log.DebugFormat("cryptogram_block: {0}", HexConverter.ConvertToHexString(cryptogram_block));
+
+            AES aes = new AES();
+            byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
+            _Log.DebugFormat("cryptogram_enc: {0}", HexConverter.ConvertToHexString(cryptogram_enc));
+
+            _IV = ByteOperation.ExtractLastBlock(cryptogram_enc, 16);
+            _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
+
+            byte[] data = ByteOperation.Concatenate(new byte[] { key_id }, cryptogram_enc);
+            _Log.DebugFormat("data: {0}", HexConverter.ConvertToHexString(data));
+
+            APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xC4,
+                Data = data
+            };
+            _Log.Debug(cmd_ChangeKey.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_ChangeKey);
+            _Log.Debug(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Create Standard Data File
+        /// </summary>
+        /// <param name="file_id">ID of File (0x00 - 0x20)</param>
+        /// <param name="communication">Type of File Communicaton</param>
+        /// <param name="accessRights">Access Rights for File</param>
+        /// <param name="size">Size of File in Bytes</param>
+        public void CreateFile_Standard(byte file_id, FileCommunication communication, UInt16 accessRights, UInt32 size)
+        {
+            if (file_id >= 0x20)
+            {
+                throw new ArgumentOutOfRangeException("FileID is to large");
+            }
+            _Log.DebugFormat("Create STD File: {0}", file_id);
+
+            byte[] accessRights_byte = BitConverter.GetBytes(accessRights);
+            byte[] size_byte_tolong = BitConverter.GetBytes(size);
+            // Use only 3 Bytes
+            byte[] size_byte = new byte[]
+            {
+                size_byte_tolong[0],
+                size_byte_tolong[1],
+                size_byte_tolong[2],
+            };
+
+            byte[] data = new byte[]
+            {
+                file_id,
+                (byte)communication
+            };
+
+            APDUCommand cmd_CreateFile_Standard = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xCD,
+                Data = ByteOperation.Concatenate(data, accessRights_byte, size_byte)
+            };
+            _Log.Debug(cmd_CreateFile_Standard.ToString());
+
+            APDUResponse response = _Card.Transmit(cmd_CreateFile_Standard);
+            _Log.DebugFormat(response.ToString());
+
+            CheckAPDUResponse(response);
+        }
+
+        /// <summary>
+        /// Write Data to File
+        /// </summary>
+        /// <param name="file_id">ID of File (0x00 - 0x20)</param>
+        /// <param name="offset">Offset for File</param>
+        /// <param name="data">Data to write</param>
+        public void WriteData(byte file_id, UInt32 offset, byte[] data)
+        {
+            if (file_id >= 0x20)
+            {
+                throw new ArgumentOutOfRangeException("FileID is to large");
+            }
+            _Log.DebugFormat("Write Data to File: {0}", file_id);
+
+            int max_write_bytes_pre_transaction = 47;
+            byte[] write_buffer;
+
+            long bytes_writed = 0;
+            long length = data.Length;
+
+            while (bytes_writed != data.Length)
+            {
+                byte[] file_id_array = new byte[]
+                {
+                    file_id
+                };
+
+                byte[] offset_byte_tolong = BitConverter.GetBytes(offset + bytes_writed);
+                // Use only 3 Bytes
+                byte[] offset_byte = new byte[]
+                {
+                offset_byte_tolong[0],
+                offset_byte_tolong[1],
+                offset_byte_tolong[2],
+                };
+
+                long bytes_towrite;
+                if (length - bytes_writed < max_write_bytes_pre_transaction)
+                {
+                    bytes_towrite = length - bytes_writed;
+                }
+                else
+                {
+                    bytes_towrite = max_write_bytes_pre_transaction;
+                }
+
+                byte[] length_byte_tolong = BitConverter.GetBytes(bytes_towrite);
+
+                write_buffer = ByteOperation.GetSubArray(data, bytes_writed, bytes_towrite);
+                bytes_writed += bytes_towrite;
+
+                // Use only 3 Bytes
+                byte[] length_byte = new byte[]
+                {
+                    length_byte_tolong[0],
+                    length_byte_tolong[1],
+                    length_byte_tolong[2],
+                };
+
+                APDUCommand cmd_WriteData = new APDUCommand(IsoCase.Case4Short)
+                {
+                    CLA = 0x90,
+                    INS = 0x3D,
+                    Data = ByteOperation.Concatenate(file_id_array, offset_byte, length_byte, write_buffer)
+                };
+                _Log.Debug(cmd_WriteData.ToString());
+
+                APDUResponse response = _Card.Transmit(cmd_WriteData);
+                _Log.Debug(response.ToString());
+
+                CheckAPDUResponse(response);
+            }
+        }
+
+        /// <summary>
+        /// Read Data from File
+        /// </summary>
+        /// <param name="file_id">ID of File (0x00 - 0x20)</param>
+        /// <param name="offset">Offset for File</param>
+        /// <param name="length">Lenght of Data</param>
+        public byte[] ReadData(byte file_id, UInt32 offset, UInt32 length)
+        {
+            if (file_id >= 0x20)
+            {
+                throw new ArgumentOutOfRangeException("FileID is to large");
+            }
+            _Log.DebugFormat("Read Data from File: {0}", file_id);
+
+            int max_read_bytes_pre_transaction = 47;
+            long bytes_readed = 0;
+
+            List<byte> read_data = new List<byte>();
+
+            while (bytes_readed != length)
+            {
+                byte[] data = new byte[]
+                {
+                    file_id
+                };
+
+                byte[] offset_byte_tolong = BitConverter.GetBytes(offset + bytes_readed);
+                // Use only 3 Bytes
+                byte[] offset_byte = new byte[]
+                {
+                offset_byte_tolong[0],
+                offset_byte_tolong[1],
+                offset_byte_tolong[2],
+                };
+
+                long bytes_toread;
+                if (length - bytes_readed < max_read_bytes_pre_transaction)
+                {
+                    bytes_toread = length - bytes_readed;
+                }
+                else
+                {
+                    bytes_toread = max_read_bytes_pre_transaction;
+                }
+
+                byte[] length_byte_tolong = BitConverter.GetBytes(bytes_toread);
+                bytes_readed += bytes_toread;
+
+                // Use only 3 Bytes
+                byte[] length_byte = new byte[]
+                {
+                    length_byte_tolong[0],
+                    length_byte_tolong[1],
+                    length_byte_tolong[2],
+                };
+
+                APDUCommand cmd_ReadData = new APDUCommand(IsoCase.Case4Short)
+                {
+                    CLA = 0x90,
+                    INS = 0xBD,
+                    Data = ByteOperation.Concatenate(data, offset_byte, length_byte)
+                };
+                _Log.Debug(cmd_ReadData.ToString());
+
+                APDUResponse response = _Card.Transmit(cmd_ReadData);
+                _Log.Debug(response.ToString());
+
+                CheckAPDUResponse(response);
+
+                // Remove CMAC from Body
+                read_data.AddRange(ByteOperation.GetSubArray(response.Body, 0, bytes_toread));
+            }
+
+            return read_data.ToArray();
+        }
+
+        /// <summary>
+        /// Get all ApplicationIDS from PICC
+        /// </summary>
+        /// <returns>AIDs (3 Byte) as Array</returns>
+        //public UInt32[] GetApplicationIDs()
+        //{
+        //    _Log.Debug("Start GetApplicationIDs");
+
+        //    APDUCommand cmd = new APDUCommand(IsoCase.Case2Short)
+        //    {
+        //        CLA = 0x90,
+        //        INS = (byte)APDUInstructions.GET_APPLICATION_IDS
+        //    };
+
+        //    APDUResponse response = _Card.Transmit(cmd);
+
+        //    CheckAPDUResponse(response);
+
+        //    if (response.Body.Length % 3 != 0)
+        //    {
+        //        throw new Exception(string.Format("Invalid body length (was: {0}).", response.Body.Length));
+        //    }
+
+        //    if (response.Body.Length == 0)
+        //    {
+        //        throw new Exception("Missing PICC Entry 0x000000.");
+        //    }
+
+        //    List<UInt32> applicationIDs = new List<UInt32>();
+
+        //    for (int i = 0; i < response.Body.Length; i += 3)
+        //    {
+        //        UInt32 new_applicationID = 0;
+        //        new_applicationID = (UInt32)((response.Body[i] << 16) + (response.Body[i + 1] << 8) + response.Body[i + 2]);
+        //        applicationIDs.Add(new_applicationID);
+        //    }
+
+        //    _Log.Debug("End GetApplicationIDs");
+
+        //    return applicationIDs.ToArray();
+        //}
+
+        /// <summary>
+        /// Delete Application by ID
+        /// </summary>
+        /// <param name="id">3 Byte ID</param>
+        //public void DeleteApplication(UInt32 id)
+        //{
+        //    byte[] id_byte = BitConverter.GetBytes(id);
+
+        //    APDUCommand cmd = new APDUCommand(IsoCase.Case4Short)
+        //    {
+        //        CLA = 0x90,
+        //        INS = (byte)APDUInstructions.DELETE_APPLICATION,
+        //        Data = new byte[]
+        //        {
+        //            id_byte[0],
+        //            id_byte[1],
+        //            id_byte[2]
+        //        },
+        //        Le = 0x00
+        //    };
+
+        //    APDUResponse response = _Card.Transmit(cmd);
+        //    CheckAPDUResponse(response);
+        //}
+        #endregion
+        #endregion
+    }
+}

NFC/Exceptions/APDUException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace NFC.Exceptions
+{
+    public class APDUException : Exception
+    {
+        public readonly byte ResponseCode;
+    }
+}

NFC/Exceptions/CardUnavailableException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace NFC.Exceptions
+{
+    public class CardUnavailableException : Exception
+    {
+
+    }
+}

NFC/Exceptions/ReaderUnavailableException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace NFC.Exceptions
+{
+    public class ReaderUnavailableException : Exception
+    {
+        
+    }
+}

NFC/Helper/ByteOperation.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+
+namespace NFC.Helper
+{
+    public static class ByteOperation
+    {
+        /// <summary>
+        /// Generate Byte Array filled with 0
+        /// </summary>
+        /// <param name="size">Size of Array</param>
+        public static byte[] GenerateEmptyArray(uint size)
+        {
+            byte[] key = new byte[size];
+            for (int i = 0; i < size; i++)
+            {
+                key[i] = 0;
+            }
+
+            return key;
+        }
+
+        /// <summary>
+        /// Get Range of Array Elements
+        /// </summary>
+        /// <param name="array">Array</param>
+        /// <param name="offset">Offset in Byte</param>
+        /// <param name="length">Lenght to read in Byte</param>
+        /// <returns>new Array with Range of Array Elements</returns>
+        public static byte[] GetSubArray(byte[] array, long offset, long length)
+        {
+            byte[] subarray = new byte[length];
+            for (long i = offset; i < offset + length; i++)
+            {
+                subarray[i - offset] = array[i];
+            }
+            return subarray;
+        }
+
+        /// <summary>
+        /// Return a copy of the last Block of data
+        /// </summary>
+        /// <param name="data">Data compatible to blocksize</param>
+        /// <param name="blocksize">in byte</param>
+        public static byte[] ExtractLastBlock(byte[] data, uint blocksize)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("Data cannot be null.");
+            }
+
+            if (data.Length % blocksize != 0)
+            {
+                throw new ArgumentException(string.Format("Data is not compatible with blocksize(data(length):{0}, blocksize:{1}.", data.Length, blocksize));
+            }
+
+            byte[] lastblock = new byte[blocksize];
+
+            for (int i = 0; i < blocksize; i++)
+            {
+                lastblock[i] = data[data.Length - blocksize + i];
+            }
+
+            return lastblock;
+        }
+
+        /// <summary>
+        /// Expand Array to Block Size, fill with 0x00
+        /// </summary>
+        /// <param name="data"></param>
+        public static byte[] ExpandToBlockSize(byte[] data, uint bocksize)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("Data cannot be null.");
+            }
+
+            int diff = data.Length % (int)bocksize;
+            if (diff == 0)
+            {
+                return data;
+            }
+
+            byte[] expand = new byte[data.Length + bocksize - diff];
+
+            data.CopyTo(expand, 0);
+
+            for (int i = expand.Length - 1; i > data.Length - 1; i--)
+            {
+                expand[i] = 0x00;
+            }
+
+            return expand;
+        }
+
+        /// <summary>
+        /// Rotates Array to the left
+        /// </summary>
+        /// <param name="data">Data</param>
+        /// <returns>Copy of data</returns>
+        public static byte[] RotateLeft(byte[] data)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("Data cannot be null.");
+            }
+
+            byte[] rotate = new byte[data.Length];
+            data.CopyTo(rotate, 0);
+
+            byte tmp = rotate[0];
+            for (var i = 0; i < rotate.Length - 1; i++)
+            {
+                rotate[i] = rotate[i + 1];
+            }
+            rotate[rotate.Length - 1] = tmp;
+
+            return rotate;
+        }
+
+        /// <summary>
+        /// Rotates Array to the right
+        /// </summary>
+        /// <param name="data">Data</param>
+        /// <returns>Copy of data</returns>
+        public static byte[] RotateRight(byte[] data)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("Data cannot be null.");
+            }
+
+            byte[] rotate = new byte[data.Length];
+            data.CopyTo(rotate, 0);
+
+            byte tmp = rotate[rotate.Length - 1];
+            for (var i = rotate.Length - 1; i > 0; i--)
+            {
+                rotate[i] = rotate[i - 1];
+            }
+            rotate[0] = tmp;
+
+            return rotate;
+        }
+
+        /// <summary>
+        /// Concatenates Arrays
+        /// </summary>
+        /// <param name="data">List of Byte Array</param>
+        public static byte[] Concatenate(params byte[][] data)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("Data cannot be null.");
+            }
+
+            List<byte> cat = new List<byte>();
+
+            foreach (byte[] d in data)
+            {
+                cat.AddRange(d);
+            }
+
+            return cat.ToArray();
+        }
+
+        /// <summary>
+        /// Boolean Operation XOR on all Bytes
+        /// </summary>
+        /// <param name="a">Array A</param>
+        /// <param name="b">Array B</param>
+        /// <returns>Copy of Data</returns>
+        public static byte[] XOR(byte[] a, byte[] b)
+        {
+            if (a == null)
+            {
+                throw new ArgumentNullException("Array A cannot be null.");
+            }
+
+            if (b == null)
+            {
+                throw new ArgumentNullException("Array B cannot be null.");
+            }
+
+            if (a.Length != b.Length)
+            {
+                throw new ArgumentException(string.Format("Arrays are not same Length(Length A:{0}, Lenght B:{1})", a.Length, b.Length));
+            }
+
+            byte[] c = new byte[a.Length];
+
+            for (int i = 0; i < a.Length; i++)
+            {
+                c[i] = (byte)(a[i] ^ b[i]);
+            }
+
+            return c;
+        }
+    }
+}

NFC/Helper/Crypto/CRC/CRC16.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace NFC.Helper.Crypto.CRC
+{
+    /// <summary>
+    /// CRC16 for DESFire Card
+    /// </summary>
+    public class CRC16
+    {
+        public UInt16 Polynomial { get; } = 0x8408;
+
+        public UInt16 InitValue { get; } = 0x6363;
+
+        public UInt16 Calculate(byte[] data, UInt16 crc16)
+        {
+            for (int i = 0; i < data.Length; i++)
+            {
+                crc16 ^= data[i];
+                for (int b = 0; b < 8; b++)
+                {
+                    bool b_Bit = (crc16 & 0x01) > 0;
+                    crc16 >>= 1;
+                    if (b_Bit)
+                    {
+                        crc16 ^= Polynomial;
+                    }
+                }
+            }
+            return crc16;
+        }
+
+        public byte[] Calculate(params byte[][] data)
+        {
+            UInt16 crc16 = InitValue;
+
+            foreach(byte[] d in data)
+            {
+                crc16 = Calculate(d, crc16);
+            }
+
+            return BitConverter.GetBytes(crc16);
+        }
+    }
+}

NFC/Helper/Crypto/CRC/CRC32.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace NFC.Helper.Crypto.CRC
+{
+    /// <summary>
+    /// CRC32 for DESFire Card
+    /// </summary>
+    public class CRC32
+    {
+        public UInt32 Polynomial { get; } = 0xEDB88320;
+
+        public UInt32 InitValue { get; } = 0xFFFFFFFF;
+
+        public UInt32 Calculate(byte[] data, UInt32 crc32)
+        {
+            for (int i = 0; i < data.Length; i++)
+            {
+                crc32 ^= data[i];
+                for (int b = 0; b < 8; b++)
+                {
+                    bool b_Bit = (crc32 & 0x01) > 0;
+                    crc32 >>= 1;
+                    if (b_Bit)
+                    {
+                        crc32 ^= Polynomial;
+                    }
+                }
+            }
+            return crc32;
+        }
+
+        public byte[] Calculate(params byte[][] data)
+        {
+            UInt32 crc32 = InitValue;
+
+            foreach(byte[] d in data)
+            {
+                crc32 = Calculate(d, crc32);
+            }
+
+            return BitConverter.GetBytes(crc32);
+        }
+    }
+}

NFC/Helper/Crypto/Cipher/AES.cs

@@ -0,0 +1,48 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace NFC.Helper.Crypto.Cipher
+{
+    public class AES : ICipher
+    {
+        public uint BlockSize { get; } = 16;
+
+        public uint KeySize { get; } = 16;
+
+        public byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            AesEngine engine = new AesEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Encrypt
+            cipher.Init(true, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+
+        public byte[] Decrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            AesEngine engine = new AesEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Decrypt
+            cipher.Init(false, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+    }
+}

NFC/Helper/Crypto/Cipher/TDES.cs

@@ -0,0 +1,49 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace NFC.Helper.Crypto.Cipher
+{
+    public class TDES : ICipher
+    {
+        public uint BlockSize { get; } = 8;
+
+        // Two times the DES Key
+        public uint KeySize { get; } = 16;
+
+        public byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Encrypt
+            cipher.Init(true, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+
+        public byte[] Decrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Decrypt
+            cipher.Init(false, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+    }
+}

NFC/Helper/Crypto/Cipher/TDES_2K.cs

@@ -0,0 +1,48 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace NFC.Helper.Crypto.Cipher
+{
+    public class TDES_2K : ICipher
+    {
+        public uint BlockSize { get; } = 8;
+
+        public uint KeySize { get; } = 16;
+
+        public byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Encrypt
+            cipher.Init(true, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+
+        public byte[] Decrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Decrypt
+            cipher.Init(false, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+    }
+}

NFC/Helper/Crypto/Cipher/TDES_3K.cs

@@ -0,0 +1,48 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace NFC.Helper.Crypto.Cipher
+{
+    public class TDES_3K : ICipher
+    {
+        public uint BlockSize { get; } = 8;
+
+        public uint KeySize { get; } = 24;
+
+        public byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Encrypt
+            cipher.Init(true, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+
+        public byte[] Decrypt(byte[] data, byte[] key, byte[] iv)
+        {
+            DesEngine engine = new DesEdeEngine();
+            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
+            BufferedBlockCipher cipher = new BufferedBlockCipher(blockCipher);
+            KeyParameter keyParam = new KeyParameter(key);
+            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv);
+
+            // Decrypt
+            cipher.Init(false, keyParamWithIV);
+            byte[] outputBytes = new byte[cipher.GetOutputSize(data.Length)];
+            int length = cipher.ProcessBytes(data, outputBytes, 0);
+            cipher.DoFinal(outputBytes, length);
+
+            return outputBytes;
+        }
+    }
+}

NFC/Helper/Crypto/CipherKey.cs

@@ -0,0 +1,182 @@
+using System;
+
+namespace NFC.Helper.Crypto
+{
+    /// <summary>
+    /// Key for DESFire Card
+    /// </summary>
+    public class CipherKey
+    {
+        #region Constructors
+        /// <summary>
+        /// Creates Key from Array
+        /// </summary>
+        /// <param name="key">Key</param>
+        /// <param name="cipher">Cipher for Key</param>
+        /// <param name="keyVersion">Version of Key</param>
+        public CipherKey(byte[] key, CipherType cipher, byte keyVersion)
+        {
+            _Cipher = cipher;
+
+            if (cipher == CipherType.AES && keyVersion < 0x10)
+            {
+                throw new ArgumentOutOfRangeException("KeyVersion is to low for AES Key (Minimum = 0x10)");
+            }
+            _KeyVersion = keyVersion;
+
+            if (!CheckKey(key, cipher))
+            {
+                throw new ArgumentException("Key is not vaild for CipherType");
+            }
+
+            if (cipher == CipherType.TDES || cipher == CipherType.TDES_2K || cipher == CipherType.TDES_3K)
+            {
+                _Key = SetKeyVersion(key, keyVersion);
+            }
+            else
+            {
+                _Key = key;
+            }
+        }
+
+        /// <summary>
+        /// Creates Key from String
+        /// </summary>
+        /// <param name="key">Key</param>
+        /// <param name="cipher">Cipher for Key</param>
+        /// <param name="keyVersion">Version of Key</param>
+        public CipherKey(string key, CipherType cipher, byte keyVersion) : this(HexConverter.ConvertFromHexString(key), cipher, keyVersion)
+        {
+
+        }
+
+        /// <summary>
+        /// Generates Empty Key
+        /// </summary>
+        /// <param name="cipher">Cipher for Key</param>
+        /// <param name="keyVerion"></param>
+        public CipherKey(CipherType cipher)
+        {
+            _Cipher = cipher;
+            _Key = GenerateEmptyKey(cipher);
+
+            if (cipher == CipherType.AES)
+            {
+                _KeyVersion = 0x10;
+            }
+            else
+            {
+                _KeyVersion = 0x00;
+            }
+        }
+        #endregion
+
+        #region Properties
+        /// <summary>
+        /// Key as Array
+        /// </summary>
+        public byte[] _Key { get; private set; }
+
+        /// <summary>
+        /// CipherType of Key
+        /// </summary>
+        public CipherType _Cipher { get; private set; }
+
+        /// <summary>
+        /// KeyVersion of Key
+        /// For AES 0x10 is minimum
+        /// </summary>
+        public byte _KeyVersion { get; private set; }
+        #endregion
+
+        #region Methods
+        /// <summary>
+        /// Generate Empty Key for CipherType
+        /// </summary>
+        /// <param name="cipher">Type of Cipher</param>
+        public byte[] GenerateEmptyKey(CipherType cipher)
+        {
+            uint size = GetKeySize(cipher);
+
+            byte[] key = new byte[size];
+            for (int i = 0; i < size; i++)
+            {
+                key[i] = 0;
+            }
+
+            return key;
+        }
+
+        /// <summary>
+        /// Check Key Array
+        /// </summary>
+        /// <param name="key">Key</param>
+        /// <param name="cipher">Cipher Type of Key</param>
+        public bool CheckKey(byte[] key, CipherType cipher)
+        {
+            if (key.Length != GetKeySize(cipher))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Get KeySize for CipherType
+        /// </summary>
+        /// <param name="cipher">Type of Cipher</param>
+        public uint GetKeySize(CipherType cipher)
+        {
+            switch (cipher)
+            {
+                case CipherType.TDES:
+                    return 16;
+                case CipherType.TDES_2K:
+                    return 16;
+                case CipherType.TDES_3K:
+                    return 24;
+                case CipherType.AES:
+                    return 16;
+                default:
+                    throw new ArgumentOutOfRangeException("Unknown CipherType.");
+            }
+        }
+
+        /// <summary>
+        /// Set Key Version for DES/TDES Keys
+        /// KeyVersion is stored in the LSBits of the first 8 Bytes
+        /// Parity Bits are not used from DESFire Cars
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="version"></param>
+        /// <returns></returns>
+        public byte[] SetKeyVersion(byte[] key, byte version)
+        {
+            byte[] pow2 = new byte[]
+            {
+                0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
+            };
+
+            byte[] new_key = new byte[key.Length];
+            key.CopyTo(new_key, 0);
+
+            for (int i = 0; i < 8; i++)
+            {
+                if ((version & pow2[i]) > 0)
+                {
+                    new_key[i] = (byte)(new_key[5] | 0x01);
+                }
+                else
+                {
+                    new_key[i] = (byte)(new_key[5] & 0x7F);
+                }
+            }
+
+            return new_key;
+        }
+        #endregion
+    }
+}

NFC/Helper/Crypto/CipherType.cs

@@ -0,0 +1,25 @@
+namespace NFC.Helper.Crypto
+{
+    public enum CipherType
+    {
+        /// <summary>
+        /// DES / Triple DES
+        /// </summary>
+        TDES,
+
+        /// <summary>
+        /// Triple DES with 2 DES Keys
+        /// </summary>
+        TDES_2K,
+
+        /// <summary>
+        /// Triple DES with 3 DES Keys
+        /// </summary>
+        TDES_3K,
+
+        /// <summary>
+        /// AES
+        /// </summary>
+        AES
+    }
+}

NFC/Helper/Crypto/ICipher.cs

@@ -0,0 +1,32 @@
+namespace NFC.Helper.Crypto
+{
+    public interface ICipher
+    {
+        /// <summary>
+        /// Size of Cipher Block in Byte
+        /// </summary>
+        uint BlockSize { get; }
+
+        /// <summary>
+        /// Size of Key in Byte
+        /// </summary>
+        uint KeySize { get; }
+
+        /// <summary>
+        /// Encrypt Data
+        /// </summary>
+        /// <param name="data">Data in BlockSize</param>
+        /// <param name="key">Key</param>
+        /// <param name="IV">Initialisation Vector</param>
+        /// <returns></returns>
+        byte[] Encrypt(byte[] data, byte[] key, byte[] IV);
+
+        /// <summary>
+        /// Decrypt Data
+        /// </summary>
+        /// <param name="data">Data in BlockSize</param>
+        /// <param name="key">Key</param>
+        /// <param name="IV">Initialisation Vector</param>
+        byte[] Decrypt(byte[] data, byte[] key, byte[] IV);
+    }
+}

NFC/Helper/HexConverter.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace NFC.Helper
+{
+    /// <summary>
+    /// Converts to and from Byte Array from and to String
+    /// </summary>
+    public static class HexConverter
+    {
+        /// <summary>
+        /// Converts byte[] to string with HEX Code
+        /// No 0x is created
+        /// </summary>
+        /// <param name="data">Data</param>
+        public static string ConvertToHexString(byte[] data)
+        {
+            return BitConverter.ToString(data).Replace("-", "").ToLower();
+        }
+
+        /// <summary>
+        /// Converts string with HEX Code to byte[]
+        /// No 0x is requiered
+        /// </summary>
+        /// <param name="data">Data</param>
+        public static byte[] ConvertFromHexString(string data)
+        {
+            if (data.Length % 2 == 1)
+                throw new Exception("Data Length is uneven.");
+
+            byte[] arr = new byte[data.Length >> 1];
+
+            for (int i = 0; i < data.Length >> 1; ++i)
+            {
+                arr[i] = (byte)((GetHexVal(data[i << 1]) << 4) + (GetHexVal(data[(i << 1) + 1])));
+            }
+
+            return arr;
+        }
+
+        private static int GetHexVal(char hex)
+        {
+            int val = (int)hex;
+            //For uppercase A-F letters:
+            //return val - (val < 58 ? 48 : 55);
+            //For lowercase a-f letters:
+            //return val - (val < 58 ? 48 : 87);
+            //Or the two combined, but a bit slower:
+            return val - (val < 58 ? 48 : (val < 97 ? 55 : 87));
+        }
+    }
+}

NFC/Interfaces/ICard.cs

@@ -0,0 +1,22 @@
+namespace NFC.Interfaces
+{
+    public interface ICard
+    {
+        /// <summary>
+        /// Connect to Smartcard
+        /// </summary>
+        void Connect();
+
+        /// <summary>
+        /// Disconnect from Smartcard
+        /// </summary>
+        void Disconnect();
+
+        /// <summary>
+        /// Transmit APDU Command to Smartcard
+        /// </summary>
+        /// <param name="apdu_cmd">Application Protocol Data Unit Command - ISO 7816</param>
+        /// <returns>Application Protocol Data Unit Response - ISO 7816</returns>
+        APDUResponse Transmit(APDUCommand apdu_cmd);
+    }
+}

NFC/Interfaces/IHardware.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace NFC.Interfaces
+{
+    /// <summary>
+    /// Abstract representation of the platform specific NFC Hardware
+    /// </summary>
+    public interface IHardware
+    {
+        /// <summary>
+        /// Check if the device has nfc support
+        /// </summary>
+        /// <returns>Returns true if the device supports NFC</returns>
+        bool IsAvailable();
+
+        /// <returns>Returns all available readers</returns>
+        string[] GetReaders();
+
+        /// <summary>
+        /// Create a new reader instance from the specified id
+        /// </summary>
+        /// <returns>Returns the spatform specific reader that corresponds to the id</returns>
+        /// <exception cref="ArgumentException">Invalid reader id</exception>
+        IReader OpenReader(string readerID);
+    }
+}

NFC/Interfaces/IReader.cs

@@ -0,0 +1,24 @@
+namespace NFC.Interfaces
+{
+    public delegate void ReaderEventHandler(object sender, ICard card);
+
+    /// <summary>
+    /// Abstraction of a platform-specifc reader that can communicate with NFC cards
+    /// </summary>
+    public interface IReader
+    {
+        /// <summary>
+        /// Event that will be called when a new tag was discovered
+        /// </summary>
+        event ReaderEventHandler CardDiscovered;
+
+        /// <summary>
+        /// Event that will be called when a tag that is in use gets disconnected
+        /// </summary>
+        event ReaderEventHandler CardLost;
+
+        void Start();
+
+        void Stop();
+    }
+}

NFC/IsoCase.cs

@@ -0,0 +1,16 @@
+namespace NFC
+{
+    /// <summary>
+    /// https://github.com/danm-de/pcsc-sharp/blob/246fc4303190184d6acd98a2d66f48cb7ffd7094/src/PCSC.Iso7816/IsoCase.cs
+    /// </summary>
+    public enum IsoCase
+    {
+        Case1,
+        Case2Short,
+        Case3Short,
+        Case4Short,
+        Case2Extended,
+        Case3Extended,
+        Case4Extended
+    }
+}

NFC/NFC.csproj

@@ -4,4 +4,9 @@
     <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="log4net" Version="2.0.12" />
+    <PackageReference Include="Portable.BouncyCastle" Version="1.8.10" />
+  </ItemGroup>
+
 </Project>

NFC/SCardProtocol.cs

@@ -0,0 +1,15 @@
+namespace NFC
+{
+    /// <summary>
+    /// https://github.com/danm-de/pcsc-sharp/blob/246fc4303190184d6acd98a2d66f48cb7ffd7094/src/PCSC/SCardProtocol.cs
+    /// </summary>
+    public enum SCardProtocol
+    {
+        UNSET,
+        T0,
+        T1,
+        RAW,
+        T15,
+        ANY
+    }
+}

NFC_Android/NFC_Android.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>

NFC_PCSC/Card_PCSC.cs

@@ -0,0 +1,132 @@
+using PCSC;
+using PCSC.Iso7816;
+using NFC.Interfaces;
+using NFC;
+using System;
+
+namespace NFC_PCSC
+{
+    public class Card_PCSC : ICard
+    {
+        private readonly IsoReader _ISOReader;
+        private readonly string _ReaderID;
+
+        public Card_PCSC(IsoReader isoreader, string readerID)
+        {
+            _ISOReader = isoreader;
+            _ReaderID = readerID;
+        }
+        public void Connect()
+        {
+            _ISOReader.Connect(_ReaderID, SCardShareMode.Shared, PCSC.SCardProtocol.Any);
+        }
+
+        public void Disconnect()
+        {
+            _ISOReader.Disconnect(SCardReaderDisposition.Eject);
+        }
+
+        public APDUResponse Transmit(APDUCommand apdu_cmd)
+        {
+            Response response = _ISOReader.Transmit(ConvertAPDUCommand(apdu_cmd));
+            return Convert(response);
+        }
+
+        public CommandApdu ConvertAPDUCommand(APDUCommand apdu_cmd)
+        {
+            switch(apdu_cmd.Case)
+            {
+                case NFC.IsoCase.Case1:
+                    return new CommandApdu(ConvertISOCase(apdu_cmd.Case), ConvertSCardProtocol(apdu_cmd.Protocol))
+                    {
+                        CLA = apdu_cmd.CLA,
+                        INS = apdu_cmd.INS,
+                        P1 = apdu_cmd.P1,
+                        P2 = apdu_cmd.P2
+                    };
+                case NFC.IsoCase.Case2Short:
+                    return new CommandApdu(ConvertISOCase(apdu_cmd.Case), ConvertSCardProtocol(apdu_cmd.Protocol))
+                    {
+                        CLA = apdu_cmd.CLA,
+                        INS = apdu_cmd.INS,
+                        P1 = apdu_cmd.P1,
+                        P2 = apdu_cmd.P2,
+                        Le = apdu_cmd.LE
+                    };
+                case NFC.IsoCase.Case3Short:
+                    return new CommandApdu(ConvertISOCase(apdu_cmd.Case), ConvertSCardProtocol(apdu_cmd.Protocol))
+                    {
+                        CLA = apdu_cmd.CLA,
+                        INS = apdu_cmd.INS,
+                        P1 = apdu_cmd.P1,
+                        P2 = apdu_cmd.P2,
+                        Data = apdu_cmd.Data
+                    };
+                case NFC.IsoCase.Case4Short:
+                    return new CommandApdu(ConvertISOCase(apdu_cmd.Case), ConvertSCardProtocol(apdu_cmd.Protocol))
+                    {
+                        CLA = apdu_cmd.CLA,
+                        INS = apdu_cmd.INS,
+                        P1 = apdu_cmd.P1,
+                        P2 = apdu_cmd.P2,
+                        Data = apdu_cmd.Data,
+                        Le = apdu_cmd.LE
+                    };
+                default:
+                    throw new Exception("Unknown IsoCase");
+            }
+        }
+
+        public PCSC.Iso7816.IsoCase ConvertISOCase(NFC.IsoCase isoCase)
+        {
+            switch(isoCase)
+            {
+                case NFC.IsoCase.Case1:
+                    return PCSC.Iso7816.IsoCase.Case1;
+                case NFC.IsoCase.Case2Short:
+                    return PCSC.Iso7816.IsoCase.Case2Short;
+                case NFC.IsoCase.Case3Short:
+                    return PCSC.Iso7816.IsoCase.Case3Short;
+                case NFC.IsoCase.Case4Short:
+                    return PCSC.Iso7816.IsoCase.Case4Short;
+                default:
+                    throw new Exception("Unknown IsoCase");
+            }
+        }
+
+        public PCSC.SCardProtocol ConvertSCardProtocol(NFC.SCardProtocol sCardProtocol)
+        {
+            switch (sCardProtocol)
+            {
+                case NFC.SCardProtocol.UNSET:
+                    return PCSC.SCardProtocol.Unset;
+                case NFC.SCardProtocol.T0:
+                    return PCSC.SCardProtocol.T0;
+                case NFC.SCardProtocol.T1:
+                    return PCSC.SCardProtocol.T1;
+                case NFC.SCardProtocol.RAW:
+                    return PCSC.SCardProtocol.Raw;
+                case NFC.SCardProtocol.T15:
+                    return PCSC.SCardProtocol.T15;
+                case NFC.SCardProtocol.ANY:
+                    return PCSC.SCardProtocol.Any;
+                default:
+                    throw new NotSupportedException("Unknown SCardProtocol");
+            }
+        }
+
+        public APDUResponse Convert(Response response)
+        {
+            ResponseApdu responseApdu = response.Get(0);
+
+            APDUResponse apduResponse = new APDUResponse()
+            {
+                SW1 = responseApdu.SW1,
+                SW2 = responseApdu.SW2,
+                Body = responseApdu.GetData()
+            };
+
+            return apduResponse;
+        }
+    }
+}

NFC_PCSC/Hardware_PCSC.cs

@@ -0,0 +1,32 @@
+using NFC.Interfaces;
+using PCSC;
+
+namespace NFC_PCSC
+{
+    public class Hardware_PCSC : IHardware
+    {
+        public string[] GetReaders()
+        {
+            var contextFactory = ContextFactory.Instance;
+            using var context = contextFactory.Establish(SCardScope.System);
+            return context.GetReaders();
+        }
+
+        public bool IsAvailable()
+        {
+            if(GetReaders().Length == 0)
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        public IReader OpenReader(string readerID)
+        {
+            return new Reader_PCSC(readerID);
+        }
+    }
+}

NFC_PCSC/NFC_PCSC.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="PCSC" Version="5.0.0" />
+    <PackageReference Include="PCSC.Iso7816" Version="5.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NFC\NFC.csproj" />
+  </ItemGroup>
+
+</Project>

NFC_PCSC/Reader_PCSC.cs

@@ -0,0 +1,50 @@
+using NFC.Interfaces;
+using PCSC;
+using PCSC.Iso7816;
+using System;
+
+namespace NFC_PCSC
+{
+
+    public class Reader_PCSC : IReader, IDisposable
+    {
+        private string _ReaderID;
+        private IContextFactory _ContextFactory;
+        private ISCardContext _SCardContext;
+        private IsoReader _ISOReader;
+        private ICard _Card;
+
+        public Reader_PCSC(string readerID)
+        {
+            _ReaderID = readerID;
+        }
+
+        public event ReaderEventHandler CardDiscovered;
+        public event ReaderEventHandler CardLost;
+
+        public void Dispose()
+        {
+            Stop();
+        }
+
+        public void Start()
+        {
+            _ContextFactory = ContextFactory.Instance;
+            _SCardContext = _ContextFactory.Establish(SCardScope.System);
+            
+            _ISOReader = new IsoReader(_SCardContext);
+
+            _Card = new Card_PCSC(_ISOReader, _ReaderID);
+
+            CardDiscovered?.Invoke(this, _Card);
+        }
+
+        public void Stop()
+        {
+            CardLost?.Invoke(this, _Card);
+
+            _ISOReader.Dispose();
+            _SCardContext.Dispose();
+        }
+    }
+}

NFC_Test/APDUCommand_Test.cs

@@ -0,0 +1,118 @@
+using System;
+using NFC;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    [TestFixture]
+    public class APDUCommand_Test
+    {
+        [Test]
+        public void Compare()
+        {
+            APDUCommand command1 = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAA,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            APDUCommand command2 = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAA,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            Assert.IsTrue(command1 == command2);
+        }
+
+        [Test]
+        public void Compare_Diff()
+        {
+            APDUCommand command1 = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0xAA,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            APDUCommand command2 = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0x1A,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            Assert.IsFalse(command1 == command2);
+        }
+
+        [Test]
+        public void ToString_Case1()
+        {
+            APDUCommand command = new APDUCommand(IsoCase.Case1)
+            {
+                CLA = 0x90,
+                INS = 0x1A
+            };
+
+            Console.WriteLine(command.ToString());
+        }
+
+        [Test]
+        public void ToString_Case2()
+        {
+            APDUCommand command = new APDUCommand(IsoCase.Case2Short)
+            {
+                CLA = 0x90,
+                INS = 0x1A
+            };
+
+            Console.WriteLine(command.ToString());
+        }
+
+        [Test]
+        public void ToString_Case3()
+        {
+            APDUCommand command = new APDUCommand(IsoCase.Case3Short)
+            {
+                CLA = 0x90,
+                INS = 0x1A,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            Console.WriteLine(command.ToString());
+        }
+
+        [Test]
+        public void ToString_Case4()
+        {
+            APDUCommand command = new APDUCommand(IsoCase.Case4Short)
+            {
+                CLA = 0x90,
+                INS = 0x1A,
+                Data = new byte[]
+                {
+                    0x01, 0x02, 0x03
+                }
+            };
+
+            Console.WriteLine(command.ToString());
+        }
+    }
+}

NFC_Test/Cards/MIFARE_DESFire_Test.cs

@@ -0,0 +1,847 @@
+using NFC;
+using NFC.Cards.NXP_MIFARE_DESFire;
+using NFC.Cards.NXP_MIFARE_DESFire.Enums;
+using NFC.Cards.NXP_MIFARE_DESFire.Exceptions;
+using NFC.Helper;
+using NFC.Interfaces;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Text;
+
+namespace NFC_Test.Cards
+{
+    [TestFixture]
+    public class MIFARE_DESFire_Test
+    {
+        #region Helper Methods
+        [Test]
+        public void CheckAPDUResponse__NULL()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(null);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__UNKNOWN()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x00,
+                SW2 = 0x00
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+            Assert.Throws<Exception>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__OPERATION_OK()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+            
+            desfire.CheckAPDUResponse(response);
+        }
+
+        [Test]
+        public void CheckAPDUResponse__NO_CHANGES()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x0C
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+            desfire.CheckAPDUResponse(response);
+        }
+
+        [Test]
+        public void CheckAPDUResponse__ILLEGAL_COMMAND_CODE()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x1C
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<IllegalCommandCodeException>(
+            delegate 
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__INTEGRITY_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x1E
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<IntegrityErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__NO_SUCH_KEY()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x40
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<NoSuchKeyException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__LENGTH_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x7E
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<LengthErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__PERMISSION_DENIED()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x9D
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<PermissionDeniedException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__PARAMETER_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x9E
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ParameterErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__AUTHENTICATION_DELAY()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xAD
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<AuthenticationDelayException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__AUTHENTICATION_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xAE
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<AuthenticationErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__ADDITIONAL_FRAME()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xAF
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            desfire.CheckAPDUResponse(response);
+        }
+
+        [Test]
+        public void CheckAPDUResponse__BOUNDARY_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xBE
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<BoundaryErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__COMMAND_ABORTED()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xCA
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<CommandAbortedException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__DUPLICATE_ERROR()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xDE
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<DuplicateErrorException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+
+        [Test]
+        public void CheckAPDUResponse__FILE_NOT_FOUND()
+        {
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xF0
+            };
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<FileNotFoundException>(
+            delegate
+            {
+                desfire.CheckAPDUResponse(response);
+            });
+        }
+        #endregion
+
+        #region Crypto Operation
+        [Test]
+        public void GenerateSessionKey_DES()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            byte[] rndA = HexConverter.ConvertFromHexString("a541a9dc9138df07");
+            Console.WriteLine(HexConverter.ConvertToHexString(rndA));
+            byte[] rndB = HexConverter.ConvertFromHexString("cbe55aa893b2da25");
+            Console.WriteLine(HexConverter.ConvertToHexString(rndB));
+
+            byte[] expected_sessionkey = HexConverter.ConvertFromHexString("a541a9dccbe55aa8a541a9dccbe55aa8");
+            Console.WriteLine(HexConverter.ConvertToHexString(expected_sessionkey));
+
+            byte[] sessionkey = desfire.GenerateSesionKey_DES(rndA, rndB);
+            Console.WriteLine(HexConverter.ConvertToHexString(sessionkey));
+            Assert.AreEqual(expected_sessionkey, sessionkey);
+        }
+
+        [Test]
+        public void GenerateSessionKey_AES()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            byte[] rndA = HexConverter.ConvertFromHexString("bc14dfde20074617e45a8822f06fdd91");
+            Console.WriteLine(HexConverter.ConvertToHexString(rndA));
+            byte[] rndB = HexConverter.ConvertFromHexString("482ddc54426e6dee560413b8d95471f5");
+            Console.WriteLine(HexConverter.ConvertToHexString(rndB));
+
+            byte[] expected_sessionkey = HexConverter.ConvertFromHexString("bc14dfde482ddc54f06fdd91d95471f5");
+            Console.WriteLine(HexConverter.ConvertToHexString(expected_sessionkey));
+
+            byte[] sessionkey = desfire.GenerateSesionKey_AES(rndA, rndB);
+            Console.WriteLine(HexConverter.ConvertToHexString(sessionkey));
+            Assert.AreEqual(expected_sessionkey, sessionkey);
+        }
+        #endregion
+
+        #region Configuration Generator
+        [Test]
+        public void GenerateKeySetting1()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.AreEqual(0x0B, desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE));
+        }
+
+        [Test]
+        public void GenerateKeySetting1_ChangeKey()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+            Assert.AreEqual(0x1B, desfire.GenerateKeySetting1(0x01, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE));
+        }
+
+        [Test]
+        public void GenerateKeySetting1_Wrong_KeyID()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.GenerateKeySetting1(0x10, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+            });
+        }
+
+        [Test]
+        public void GenerateKeySetting2()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.AreEqual(0x82, desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 0x02));
+        }
+
+        [Test]
+        public void GenerateKeySetting2_Wrong_KeyNumbers()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 0x10);
+            });
+        }
+
+
+        [Test]
+        public void GenerateFileAccessRights()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.AreEqual(0x1234, desfire.GenerateFileAccessRights(0x01, 0x02, 0x03, 0x04));
+        }
+
+        [Test]
+        public void GenerateFileAccessRights_OutOfRange()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.GenerateFileAccessRights(0x10, 0x00, 0x00, 0x00);
+            });
+        }
+        #endregion
+
+        #region DESFire Commands
+        [Test]
+        public void SelectApplication()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "905a00000333221100")).Returns(response);
+
+            desfire.SelectApplication(0x112233);
+        }
+
+        [Test]
+        public void SelectApplication_InvalidAID()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.SelectApplication(0xFF000000);
+            });
+        }
+
+        [Test]
+        public void AuthenticateISO_DES()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response_challenge_request = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xAF,
+                Body = HexConverter.ConvertFromHexString("2bf9a938ecca02e2")
+            };
+
+            APDUResponse response_challenge_response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("07d825607a552e2e")
+            };
+
+            byte[] rndA = HexConverter.ConvertFromHexString("5f7d1dd12d979173");
+            byte[] key = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "901a0000010000")).Returns(response_challenge_request);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90af000010f8cdb2eaa42a3167dfcb53852ce267fd00")).Returns(response_challenge_response);
+
+            desfire.AuthenticateISO_DES(0x00, key, rndA);
+
+            byte[] expected_sessionkey = HexConverter.ConvertFromHexString("5f7d1dd1f449db5c5f7d1dd1f449db5c");
+            byte[] expected_iv = HexConverter.ConvertFromHexString("0000000000000000");
+
+            Assert.AreEqual(expected_sessionkey, desfire._SessionKey);
+            Assert.AreEqual(expected_iv, desfire._IV);
+        }
+
+        [Test]
+        public void AuthenticateISO_DES_InvalidKeyNo()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.AuthenticateISO_DES(0x0F, null);
+            });
+        }
+
+        [Test]
+        public void Format()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90fc000000")).Returns(response);
+
+            desfire.Format();
+        }
+
+        [Test]
+        public void CreateApplication()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90ca000005eeffaa0b8200")).Returns(response);
+
+            desfire.CreateApplication(0xAAFFEE, 0x0b, 0x82);
+        }
+
+        [Test]
+        public void CreateApplication_InvalidAID()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.CreateApplication(0xFF000000, 0x00, 0x00);
+            });
+        }
+
+        [Test]
+        public void AuthenticateISO_AES()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response_challenge_request = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0xAF,
+                Body = HexConverter.ConvertFromHexString("a33856932308775cf464610c2b17a558")
+            };
+
+            APDUResponse response_challenge_response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("8fdc476f6bac44fe9150e285abd68d48")
+            };
+
+            byte[] rndA = HexConverter.ConvertFromHexString("2176770e7a6eb4bef00d5e4b201d1e57");
+            byte[] key = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90aa0000010000")).Returns(response_challenge_request);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90af000020cbe9726faf54bc76b2055d0b9700e7dc97ecad5627f1d1702a16e8408d2a0ada00")).Returns(response_challenge_response);
+
+            desfire.AuthenticateISO_AES(0x00, key, rndA);
+
+            byte[] expected_sessionkey = HexConverter.ConvertFromHexString("2176770e11c512ca201d1e57fde6e15a");
+            byte[] expected_iv = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            Assert.AreEqual(expected_sessionkey, desfire._SessionKey);
+            Assert.AreEqual(expected_iv, desfire._IV);
+        }
+
+        [Test]
+        public void AuthenticateISO_AES_InvalidKeyNo()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.AuthenticateISO_AES(0x0F, null);
+            });
+        }
+
+        [Test]
+        public void ChangeKey_AES()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90c400002100c2b54a718d0251845653199909bb32e8e38bd6719e8dc21799c29c922a0984fc00")).Returns(response);
+
+            byte[] new_key = HexConverter.ConvertFromHexString("25432a462d4a614e645267556b587032");
+
+            byte[] sessionkey = HexConverter.ConvertFromHexString("a8514dd0350f3dfbc86e80744bcc9b57");
+            byte[] iv = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            desfire._SessionKey = sessionkey;
+            desfire._IV = iv;
+
+            desfire.ChangeKey_AES(0x00, new_key, 0x10);
+        }
+
+        [Test]
+        public void ChangeKey_AES_InvalidKeyNo()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.ChangeKey_AES(0x0F, null, 0x10);
+            });
+        }
+
+        [Test]
+        public void ChangeOtherKey_AES()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90c400002101a8c5a61a06f56f38dc91266fed2e87dc00a5ad72a634ff0e62c8d6d80707dd6000")).Returns(response);
+
+            byte[] new_key = HexConverter.ConvertFromHexString("25432a462d4a614e645267556b587032");
+            byte[] old_key = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            byte[] sessionkey = HexConverter.ConvertFromHexString("1677623e1e158a62dc3d128db55f947d");
+            byte[] iv = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            desfire._SessionKey = sessionkey;
+            desfire._IV = iv;
+
+            desfire.ChangeOtherKey_AES(0x01, new_key, old_key, 0x10);
+        }
+
+        [Test]
+        public void ChangeOtherKey_AES_InvalidKeyNo()
+        {
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(null);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.ChangeKey_AES(0x0F, null, 0x10);
+            });
+        }
+
+        [Test]
+        public void CreateFile_Standard()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90cd000007010000e0f0000000")).Returns(response);
+
+            UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
+            desfire.CreateFile_Standard(0x01, FileCommunication.PLAIN, accesRights, 0xF0);
+        }
+
+        [Test]
+        public void CreateFile_Standard_InvalidFID()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.CreateFile_Standard(0x21, FileCommunication.PLAIN, 0x0000, 0xF0);
+            });
+        }
+
+        [Test]
+        public void WriteData()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "903d00000f01000000080000546573743132333400")).Returns(response);
+
+            desfire.WriteData(0x01, 0, Encoding.ASCII.GetBytes("Test1234"));
+        }
+
+        [Test]
+        public void WriteData_Long()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "903d000036010000002f0000546573743132333454657374313233345465737431323334546573743132333454657374313233345465737431323300")).Returns(response);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "903d000036012f00002f0000345465737431323334546573743132333454657374313233345465737431323334546573743132333454657374313200")).Returns(response);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "903d000019015e000012000033345465737431323334546573743132333400")).Returns(response);
+
+            desfire.WriteData(0x01, 0, Encoding.ASCII.GetBytes("Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234Test1234"));
+        }
+
+        [Test]
+        public void WriteData_InvalidFileID()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.WriteData(0x21, 0x00, Encoding.ASCII.GetBytes("Test1234"));
+            });
+        }
+
+        [Test]
+        public void ReadData()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("54657374313233340000000000000000000000000000000000000000000000009100")
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90bd0000070100000020000000")).Returns(response);
+
+            byte[] data = desfire.ReadData(0x01, 0x00, 0x20);
+
+            Assert.AreEqual("Test1234", Encoding.ASCII.GetString(data).Replace("\u0000", ""));
+        }
+
+        [Test]
+        public void ReadData_CMAC()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("5465737431323334000000000000000000000000000000000000000000000000809a9bedbc559a5b9100")
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90bd0000070100000020000000")).Returns(response);
+
+            byte[] data = desfire.ReadData(0x01, 0x00, 0x20);
+
+            Assert.AreEqual("Test1234", Encoding.ASCII.GetString(data).Replace("\u0000", ""));
+        }
+
+        [Test]
+        public void ReadData_Long()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            APDUResponse response_1 = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("54657374313233340000000000000000000000000000000000000000000000000000000000000000000000000000009100")
+            };
+
+            APDUResponse response_2 = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009100")
+            };
+
+            APDUResponse response_3 = new APDUResponse()
+            {
+                SW1 = 0x91,
+                SW2 = 0x00,
+                Body = HexConverter.ConvertFromHexString("00009100")
+            };
+
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90bd000007010000002f000000")).Returns(response_1);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90bd000007012f00002f000000")).Returns(response_2);
+            card.Transmit(Arg.Is<APDUCommand>(x => HexConverter.ConvertToHexString(x.ToArray()) == "90bd000007015e000002000000")).Returns(response_3);
+
+            byte[] data = desfire.ReadData(0x01, 0x00, 0x60);
+
+            Assert.AreEqual("Test1234", Encoding.ASCII.GetString(data).Replace("\u0000", ""));
+        }
+
+        [Test]
+        public void ReadData_InvalidFileID()
+        {
+            ICard card = Substitute.For<ICard>();
+
+            NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+            Assert.Throws<ArgumentOutOfRangeException>(
+            delegate
+            {
+                desfire.ReadData(0x21, 0x00, 0x20);
+            });
+        }
+        #endregion
+    }
+}

NFC_Test/Helper/AES_Test.cs

@@ -0,0 +1,24 @@
+using NFC.Helper;
+using NFC.Helper.Crypto.Cipher;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    [TestFixture]
+    public class AES_Test
+    {
+        [Test]
+        public void Encrypt()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("8db1f942f2d7cc82f6fa1486a30f8c12104a3b07e8eb77a7ac00000000000000");
+            byte[] key = HexConverter.ConvertFromHexString("e7aff3361c3e85347993c3219a87d24b");
+            byte[] iv = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
+
+            AES aes = new AES();
+            byte[] data_enc = aes.Encrypt(data, key, iv);
+
+            byte[] data_enc_expected = HexConverter.ConvertFromHexString("3c79d74a4969ba7123e5d8f6df24493112d221fd131a4617d0eda5d92ccc1b46");
+            Assert.AreEqual(data_enc_expected, data_enc);
+        }
+    }
+}

NFC_Test/Helper/ByteOperation_Test.cs

@@ -0,0 +1,266 @@
+using NFC.Helper;
+using NUnit.Framework;
+using System;
+
+namespace NFC_Test.Helper
+{
+    public class ByteOperation_Test
+    {
+        [Test]
+        public void GenerateEmptyArray()
+        {
+            uint i = 16;
+
+            byte[] data = ByteOperation.GenerateEmptyArray(i);
+
+            for (int e = 0; e < i; e++)
+            {
+                if (data[e] != 0x00)
+                {
+                    Assert.Fail("Data is not 0x00");
+                }
+            }
+        }
+
+        [Test]
+        public void GetSubArray()
+        {
+            byte[] array = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04, 0x05
+            };
+
+            byte[] expected_subarray = new byte[]
+            {
+                0x02, 0x03, 0x04
+            };
+
+            Assert.AreEqual(expected_subarray, ByteOperation.GetSubArray(array, 1, 3));
+        }
+
+        [Test]
+        public void ExtractLastBlock()
+        {
+            byte[] data = new byte[]
+            {
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+            };
+
+            byte[] expected_lastblock = new byte[]
+            {
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+            };
+
+            byte[] lastblock = ByteOperation.ExtractLastBlock(data, 8);
+
+            Assert.AreEqual(expected_lastblock, lastblock);
+        }
+
+        [Test]
+        public void ExtractLastBlock_WrongBlocksize()
+        {
+            byte[] data = new byte[]
+            {
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+            };
+
+            Assert.Throws<ArgumentException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.ExtractLastBlock(data, 7);
+            });
+        }
+
+        [Test]
+        public void ExtractLastBlock_Null()
+        {
+            byte[] data = null;
+
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.ExtractLastBlock(data, 7);
+            });
+        }
+
+        [Test]
+        public void ExpandToBlockSize()
+        {
+            byte[] data = new byte[]
+            {
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+            };
+
+            byte[] expected_lastblock = new byte[]
+            {
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00
+            };
+
+            byte[] lastblock = ByteOperation.ExpandToBlockSize(data, 8);
+
+            Assert.AreEqual(expected_lastblock, lastblock);
+        }
+
+        [Test]
+        public void ExpandToBlockSize_Null()
+        {
+            byte[] data = null;
+
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.ExpandToBlockSize(data, 8);
+            });
+        }
+
+        [Test]
+        public void RotateLeft()
+        {
+            byte[] data = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04
+            };
+
+            byte[] expected_data_left = new byte[]
+            {
+                0x02, 0x03, 0x04, 0x01
+            };
+
+            byte[] data_left = ByteOperation.RotateLeft(data);
+
+            Assert.AreEqual(expected_data_left, data_left);
+        }
+
+        [Test]
+        public void RotateLeft_Null()
+        {
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.RotateLeft(null);
+            });
+        }
+
+        [Test]
+        public void RotateRight()
+        {
+            byte[] data = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04
+            };
+
+            byte[] expected_data_left = new byte[]
+            {
+                0x04, 0x01, 0x02, 0x03
+            };
+
+            byte[] data_left = ByteOperation.RotateRight(data);
+
+            Assert.AreEqual(expected_data_left, data_left);
+        }
+
+        [Test]
+        public void RotateRight_Null()
+        {
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.RotateRight(null);
+            });
+        }
+
+        [Test]
+        public void Concatenate()
+        {
+            byte[] data_a = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04
+            };
+
+            byte[] data_b = new byte[]
+            {
+                0x05, 0x06, 0x07, 0x08
+            };
+
+            byte[] expected_data_c = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
+            };
+
+            byte[] data_c = ByteOperation.Concatenate(data_a, data_b);
+
+            Assert.AreEqual(expected_data_c, data_c);
+        }
+
+        [Test]
+        public void Concatenate_ABC()
+        {
+            byte[] data_a = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04
+            };
+
+            byte[] data_b = new byte[]
+            {
+                0x05, 0x06, 0x07, 0x08
+            };
+
+            byte[] data_c = new byte[]
+            {
+                0x09, 0xA0, 0xB0, 0xC0
+            };
+
+            byte[] expected_data_d = new byte[]
+            {
+                0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xA0, 0xB0, 0xC0
+            };
+
+            byte[] data_d = ByteOperation.Concatenate(data_a, data_b, data_c);
+
+            Assert.AreEqual(expected_data_d, data_d);
+        }
+
+        [Test]
+        public void Concatenate_Null()
+        {
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.Concatenate(null, null);
+            });
+        }
+
+        [Test]
+        public void XOR()
+        {
+            byte[] data_a = new byte[]
+            {
+                0x00, 0xF0, 0x00, 0xF0
+            };
+
+            byte[] data_b = new byte[]
+            {
+                0x0F, 0x00, 0x0F, 0x00
+            };
+
+            byte[] expected_data_c = new byte[]
+            {
+                0x0F, 0xF0, 0x0F, 0xF0
+            };
+
+            byte[] data_c = ByteOperation.XOR(data_a, data_b);
+
+            Assert.AreEqual(expected_data_c, data_c);
+        }
+
+        [Test]
+        public void XOR_null()
+        {
+            Assert.Throws<ArgumentNullException>(
+            delegate
+            {
+                byte[] lastblock = ByteOperation.XOR(null, null);
+            });
+        }
+    }
+}

NFC_Test/Helper/CRC16_Test.cs

@@ -0,0 +1,23 @@
+using NFC.Helper;
+using NFC.Helper.Crypto.CRC;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    [TestFixture]
+    public class CRC16_Test
+    {
+        [Test]
+        [Ignore("Unknown Expected Data")]
+        public void Caluclate()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("");
+            byte[] crc_expected = HexConverter.ConvertFromHexString("");
+
+            CRC16 crc16 = new CRC16();
+            byte[] crc = crc16.Calculate(data);
+
+            Assert.AreEqual(crc_expected, crc);
+        }
+    }
+}

NFC_Test/Helper/CRC32_Test.cs

@@ -0,0 +1,22 @@
+using NFC.Helper;
+using NFC.Helper.Crypto.CRC;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    [TestFixture]
+    public class CRC32_Test
+    {
+        [Test]
+        public void Caluclate()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("c40045eeb8338ae8f49a032e85bb1114353010");
+            byte[] crc_expected = HexConverter.ConvertFromHexString("95c3894b");
+
+            CRC32 crc32 = new CRC32();
+            byte[] crc = crc32.Calculate(data);
+
+            Assert.AreEqual(crc_expected, crc);
+        }
+    }
+}

NFC_Test/Helper/HexConverter_Test.cs

@@ -0,0 +1,34 @@
+using NFC.Helper;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    public class HexConverter_Test
+    {
+        [Test]
+        public void ConvertFromHexString()
+        {
+            string s = "0180ff0a";
+
+            byte[] expected_s =
+            {
+                0x01, 0x80, 0xFF, 0x0A
+            };
+
+            Assert.AreEqual(expected_s, HexConverter.ConvertFromHexString(s));
+        }
+
+        [Test]
+        public void ConvertToHexString()
+        {
+            byte[] s =
+            {
+                0x01, 0x80, 0xFF, 0x0A
+            };
+
+            string expected_s = "0180ff0a";
+
+            Assert.AreEqual(expected_s, HexConverter.ConvertToHexString(s));
+        }
+    }
+}

NFC_Test/Helper/TDES_Test.cs

@@ -0,0 +1,55 @@
+using NFC.Helper;
+using NFC.Helper.Crypto.Cipher;
+using NUnit.Framework;
+
+namespace NFC_Test.Helper
+{
+    [TestFixture]
+    public class TDES_Test
+    {
+        [Test]
+        [Ignore("Unknown Expected Data")]
+        public void Encrypt_TDES()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("");
+            byte[] key = HexConverter.ConvertFromHexString("");
+            byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
+
+            TDES des = new TDES();
+            byte[] data_enc = des.Encrypt(data, key, iv);
+
+            byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
+            Assert.AreEqual(data_enc_expected, data_enc);
+        }
+
+        [Test]
+        [Ignore("Unknown Expected Data")]
+        public void Encrypt_TDES_2K()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("");
+            byte[] key = HexConverter.ConvertFromHexString("");
+            byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
+
+            TDES_2K des = new TDES_2K();
+            byte[] data_enc = des.Encrypt(data, key, iv);
+
+            byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
+            Assert.AreEqual(data_enc_expected, data_enc);
+        }
+
+        [Test]
+        [Ignore("Unknown Expected Data")]
+        public void Encrypt_TDES_3K()
+        {
+            byte[] data = HexConverter.ConvertFromHexString("");
+            byte[] key = HexConverter.ConvertFromHexString("");
+            byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
+
+            TDES_3K des = new TDES_3K();
+            byte[] data_enc = des.Encrypt(data, key, iv);
+
+            byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
+            Assert.AreEqual(data_enc_expected, data_enc);
+        }
+    }
+}

NFC_Test/NFC_Test.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="NSubstitute" Version="4.2.2" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NFC\NFC.csproj" />
+    <ProjectReference Include="..\NFC_PCSC\NFC_PCSC.csproj" />
+  </ItemGroup>
+
+</Project>

NFC_Test/NamespaceSetUp.cs

@@ -0,0 +1,34 @@
+using log4net.Config;
+using NUnit.Framework;
+
+namespace NFC_Test
+{
+    /// <summary>
+    /// Add log4net Output to Console Out
+    /// </summary>
+    [SetUpFixture]
+    public class NamespaceSetUp
+    {       
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            BasicConfigurator.Configure();
+        }
+    }
+}
+
+namespace NFC_Real_Test
+{
+    /// <summary>
+    /// Add log4net Output to Console Out
+    /// </summary>
+    [SetUpFixture]
+    public class NamespaceSetUp
+    {
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            BasicConfigurator.Configure();
+        }
+    }
+}

NFC_Test/REAL/REAL_DESFireCommands.cs

@@ -0,0 +1,477 @@
+using NFC.Cards.NXP_MIFARE_DESFire;
+using NFC.Cards.NXP_MIFARE_DESFire.Enums;
+using NFC.Helper.Crypto;
+using NFC.Interfaces;
+using NFC_PCSC;
+using NUnit.Framework;
+using System;
+using System.Text;
+
+namespace NFC_Test.REAL
+{
+    /// <summary>
+    /// Test all DESFire Commands with an Empty Card
+    /// The Test are ordered to check the Commands one by one
+    /// </summary>
+    [TestFixture, Explicit]
+    public class REAL_DESFireCommands
+    {
+        /// <summary>
+        /// Set ReaderID for PCSC Interface
+        /// You can get the ID from REAL_Reader_PCSC
+        /// </summary>
+        public readonly string ReaderID = "ACS ACR122U PICC Interface 0";
+
+        #region Fixed Config Properties
+        public readonly UInt32 ApplicationID = 0xAAFFEE;
+        public readonly string ApplicationMasterKey = "25432A462D4A614E645267556B587032";
+        public readonly string ApplicationKey_1 = "25432A462D4A614E645267556B587032";
+        public readonly byte FileID = 0x01;
+        public readonly byte FileSize = 0xF0;
+        #endregion
+
+        [Test, Order(1)]
+        public void SelectApplication()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(2)]
+        public void Authenticate_DES()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(3)]
+        public void Format()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(4)]
+        public void CreateApplication()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(5)]
+        public void Authenticate_AES()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(6)]
+        public void ChangeApplicationMasterKey()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                CipherKey key_aes_new = new CipherKey(ApplicationMasterKey, CipherType.AES, 0x10);
+                desfire.ChangeKey_AES(0x00, key_aes_new._Key, key_aes_new._KeyVersion);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(7)]
+        public void ChangeApplicationKey_1()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                CipherKey key_new = new CipherKey(ApplicationKey_1, CipherType.AES, 0x10);
+                desfire.ChangeOtherKey_AES(0x01, key_new._Key, key_aes._Key, key_new._KeyVersion);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(8)]
+        public void CreateFile()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
+                desfire.CreateFile_Standard(FileID, FileCommunication.PLAIN, accesRights, FileSize);
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(9)]
+        public void WriteFile()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
+                desfire.CreateFile_Standard(FileID, FileCommunication.PLAIN, accesRights, FileSize);
+
+                desfire.WriteData(FileID, 0, Encoding.ASCII.GetBytes("Test1234"));
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        [Test, Order(10)]
+        public void ReadFile()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(ReaderID);
+
+            bool test_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+
+                CipherKey key = new CipherKey(CipherType.TDES);
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, key._Key);
+
+                byte keysetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keysetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 2);
+
+                desfire.CreateApplication(ApplicationID, keysetting1, keysetting2);
+
+                desfire.SelectApplication(ApplicationID);
+
+                CipherKey key_aes = new CipherKey(CipherType.AES);
+                desfire.AuthenticateISO_AES(0x00, key_aes._Key);
+
+                UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
+                desfire.CreateFile_Standard(FileID, FileCommunication.PLAIN, accesRights, FileSize);
+
+                desfire.WriteData(FileID, 0, Encoding.ASCII.GetBytes("Test1234"));
+
+                byte[] data = desfire.ReadData(FileID, 0, FileSize);
+                Console.WriteLine(Encoding.ASCII.GetString(data).Replace("\u0000", ""));
+
+                test_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, test_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+    }
+}

NFC_Test/REAL/REAL_FabAccess_OTA.cs

@@ -0,0 +1,130 @@
+using NFC.Cards.NXP_MIFARE_DESFire;
+using NFC.Cards.NXP_MIFARE_DESFire.Enums;
+using NFC.Helper.Crypto;
+using NFC.Interfaces;
+using NFC_PCSC;
+using NUnit.Framework;
+using System;
+using System.Text;
+
+namespace NFC_Test.REAL
+{
+    [TestFixture, Explicit]
+    public class REAL_FabAccess_OTA
+    {
+        private string _ReaderID = "ACS ACR122U PICC Interface 0";
+        private UInt32 _FabAccess_AID = 0x2A472D;
+        private byte _FabAccess_FID = 0x01;
+        private UInt32 _FabAccess_FSize = 0xF0;
+
+        // Change of PICC Key is not implementet yet
+        // private CipherKey _FabAccess_Card_MasterKey = new CipherKey("294A404E635266556A576E5A72347537", CipherType.AES, 0x10);
+
+        private CipherKey _FabAccess_Application_MasterKey = new CipherKey("50645367566B59703273357638792F42", CipherType.AES, 0x10);
+        private CipherKey _FabAccess_Application_AuthKey = new CipherKey("6D5A7134743677397A24432646294A40", CipherType.AES, 0x10);
+
+        private string _FabAccess_UserDomain = "verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylooooooooooooooooooongusssssssssssssssssssssssernaaaaaaaaaaaaaaaaaaaaaaaame@fvm.fab-access.org";
+        private string _FabAccess_Domain = "fvm.fab-access.org";
+
+        private CipherKey _Default_DESKey = new CipherKey(CipherType.TDES);
+        private CipherKey _Default_AESKey = new CipherKey(CipherType.AES);
+
+        /// <summary>
+        /// Create FabAccess Application and UserData File
+        /// </summary>
+        [Test, Order(1)]
+        public void Init_EmptyCard()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(_ReaderID);
+
+            bool transmit_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(0x000000);
+                desfire.AuthenticateISO_DES(0x00, _Default_DESKey._Key);
+                desfire.Format();
+
+                desfire.AuthenticateISO_DES(0x00, _Default_DESKey._Key);
+
+                byte keySetting1 = desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
+                byte keySetting2 = desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 0x02);
+                desfire.CreateApplication(_FabAccess_AID, keySetting1, keySetting2);
+
+                desfire.SelectApplication(_FabAccess_AID);
+                desfire.AuthenticateISO_AES(0x00, _Default_AESKey._Key);
+
+                desfire.ChangeKey_AES(0x00, _FabAccess_Application_MasterKey._Key, _FabAccess_Application_MasterKey._KeyVersion);
+
+                desfire.AuthenticateISO_AES(0x00, _FabAccess_Application_MasterKey._Key);
+                desfire.ChangeOtherKey_AES(0x01, _FabAccess_Application_AuthKey._Key, _Default_AESKey._Key, _FabAccess_Application_AuthKey._KeyVersion);
+
+                UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
+                desfire.CreateFile_Standard(_FabAccess_FID, FileCommunication.PLAIN, accesRights, _FabAccess_FSize);
+
+                desfire.WriteData(_FabAccess_FID, 0, Encoding.ASCII.GetBytes(_FabAccess_UserDomain));
+
+                transmit_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, transmit_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+
+        /// <summary>
+        /// Authenticate with UserData File and AuthKey
+        /// </summary>
+        [Test, Order(2)]
+        public void Authenticate()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(_ReaderID);
+
+            bool transmit_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                NXP_MIFARE_DESFire desfire = new NXP_MIFARE_DESFire(card);
+
+                desfire.SelectApplication(_FabAccess_AID);
+                byte[] card_data = desfire.ReadData(_FabAccess_FID, 0x00, _FabAccess_FSize);
+                string userdomain = Encoding.ASCII.GetString(card_data).Replace("\u0000", "");
+
+                string domain = userdomain.Split('@')[1];
+                if(domain != _FabAccess_Domain)
+                {
+                    throw new Exception("Incorrect Domain");
+                }
+
+                desfire.SelectApplication(_FabAccess_AID);
+                desfire.AuthenticateISO_AES(0x01, _FabAccess_Application_AuthKey._Key);
+
+                transmit_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, transmit_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+    }
+}

NFC_Test/REAL/REAL_Reader_PCSC.cs

@@ -0,0 +1,62 @@
+using NFC.Interfaces;
+using NFC_PCSC;
+using NUnit.Framework;
+using System;
+
+namespace NFC_Test.REAL
+{
+    [TestFixture, Explicit]
+    public class REAL_Reader_PCSC
+    {
+        /// <summary>
+        /// Print PCSC ReaderIDs to Console Out
+        /// </summary>
+        [Test]
+        public void GetReaders()
+        {
+            IHardware hardware = new Hardware_PCSC();
+            string[] readers = hardware.GetReaders();
+
+            Console.WriteLine("PCSC Readers detected: {0}", readers.Length);
+
+            if (readers.Length > 0)
+            {
+                Console.WriteLine("List of ReaderIDs:");
+                foreach (string readerID in readers)
+                {
+                    Console.WriteLine("{0}", readerID);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Connect to specific PCSC Reader by ReaderID
+        /// </summary>
+        /// <param name="readerID">ReaderID from GetReaders</param>
+        [TestCase("ACS ACR122U PICC Interface 0")]
+        public void Connect(string readerID)
+        {
+            IHardware hardware = new Hardware_PCSC();
+            IReader reader = hardware.OpenReader(readerID);
+
+            bool connected_successfully = false;
+
+            ReaderEventHandler handler = (sender, card) =>
+            {
+                card.Connect();
+
+                connected_successfully = true;
+
+                card.Disconnect();
+            };
+
+            reader.CardDiscovered += handler;
+            reader.Start();
+
+            Assert.AreEqual(true, connected_successfully);
+
+            reader.Stop();
+            reader.CardDiscovered -= handler;
+        }
+    }
+}

NFC_iOS/NFC_iOS.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>