FabInfra-Mirror/borepin
1
0
Fork 0
mirror of https://gitlab.com/fabinfra/fabaccess/borepin.git synced 2025-04-20 10:26:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Added: Complete Real Test

Browse Source
This commit is contained in:
TheJoKlLa 2020-11-07 01:14:51 +01:00
parent 872aeccee7
commit 6c51e40891
23 changed files with 1020 additions and 1199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
NFC/ISO7816-4/APDUResponse.cs
View File

@ -1,4 +1,5 @@
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using NFC.Mifare_DESFire; using NFC.Mifare_DESFire;
@ -129,6 +130,25 @@ namespace NFC.ISO7816_4
return array; return array;
} }
public override bool Equals(object obj)
{
return obj is APDUResponse response &&
EqualityComparer<byte[]>.Default.Equals(Body, response.Body) &&
SW1 == response.SW1 &&
SW2 == response.SW2;
}
public override int GetHashCode()
{
return HashCode.Combine(Body, SW1, SW2);
}
public override string ToString()
{
string pattern = "SW1: 0x{0:x} | SW2: 0x{1:x} | Body: 0x{2:x}";
return string.Format(pattern, SW1, SW2, Body);
}
#endregion #endregion
} }
} }

2
NFC/NXP MIFARE DESFire/APDUStatusCodes.cs
View File

@ -1,6 +1,4 @@
using System; using System;
using System.Collections.Generic;
using System.Text;
namespace NFC.Mifare_DESFire namespace NFC.Mifare_DESFire
{ {

106
NFC/NXP MIFARE DESFire/CMAC.cs
View File

@ -1,106 +0,0 @@
using NFC.Crypto;
using System;
namespace NFC.NXP_MIFARE_DESFire
{
public class CMAC
{
#region Contructors
public CMAC(CipherType cipher)
{
switch(cipher)
{
case(CipherType.TDES):
_Cipher = new TDES();
break;
case(CipherType.TDES_2K):
_Cipher = new TDES_2K();
break;
case(CipherType.TDES_3K):
_Cipher = new TDES_3K();
break;
case (CipherType.AES):
_Cipher = new AES();
break;
default:
throw new ArgumentException("Unkown Cipher Type.");
}
}
public CMAC(ICipher cipher)
{
_Cipher = cipher ?? throw new ArgumentNullException();
}
#endregion
#region Properties
private ICipher _Cipher;
#endregion
#region Methods
/// <summary>
/// Generate Key with all Zeros, in KeySize
/// </summary>
public byte[] GenerateEmpytKey()
{
byte[] key = new byte[_Cipher.KeySize];
for (int i = 0; i < _Cipher.KeySize; i++)
{
key[i] = 0;
}
return key;
}
/// <summary>
/// Generate IV with all Zeros, in KeySize
/// </summary>
public byte[] GenerateEmpytIV()
{
byte[] key = new byte[_Cipher.BlockSize];
for (int i = 0; i < _Cipher.BlockSize; i++)
{
key[i] = 0;
}
return key;
}
/// <summary>
/// Encrypt Data
/// </summary>
public byte[] Encrypt(byte[] data)
{
throw new NotImplementedException();
}
/// <summary>
/// Decrypt Data
/// </summary>
public byte[] Decrypt(byte[] data)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <returns>Two Keys</returns>
public byte[][] GenerateSubKey()
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public byte[] Digest(byte[] data)
{
throw new NotImplementedException();
}
#endregion
}
}

13
NFC/NXP MIFARE DESFire/CryptoOperations.cs
View File

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace NFC.Mifare_DESFire
{
enum CryptoOperations : byte
{
TDES = 0x00,
TKTDES = 0x40,
AES = 0x80,
}
}

567
NFC/NXP MIFARE DESFire/MIFARE_DESFire.cs
View File

@ -1,5 +1,4 @@
using log4net.Repository.Hierarchy; using NFC.Crypto;
using NFC.Crypto;
using NFC.ISO7816_4; using NFC.ISO7816_4;
using NFC.Mifare_DESFire.Enums; using NFC.Mifare_DESFire.Enums;
using NFC.NXP_MIFARE_DESFire.Exceptions; using NFC.NXP_MIFARE_DESFire.Exceptions;
@ -7,7 +6,6 @@ using PCSC.Iso7816;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection;
namespace NFC.Mifare_DESFire namespace NFC.Mifare_DESFire
{ {
@ -54,7 +52,7 @@ namespace NFC.Mifare_DESFire
/// Generate Byte Array filled with 0 /// Generate Byte Array filled with 0
/// </summary> /// </summary>
/// <param name="size">Size of Array</param> /// <param name="size">Size of Array</param>
public byte[] GenerateEmptyKey(uint size) public byte[] GenerateEmptyArray(uint size)
{ {
byte[] key = new byte[size]; byte[] key = new byte[size];
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
@ -66,42 +64,12 @@ namespace NFC.Mifare_DESFire
} }
/// <summary> /// <summary>
/// Converts byte[] to string with HEX Code /// Get Range of Array Elements
/// No 0x is created
/// </summary> /// </summary>
/// <param name="data">Data</param> /// <param name="array">Array</param>
public string ConvertToHexString(byte[] data) /// <param name="offset">Offset in Byte</param>
{ /// <param name="length">Lenght to read in Byte</param>
return BitConverter.ToString(data).Replace("-", "").ToLower(); /// <returns>new Array with Range of Array Elements</returns>
}
/// <summary>
/// Converts string with HEX Code to byte[]
/// No 0x is requiered
/// </summary>
/// <param name="data">Data</param>
public 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;
}
/// <summary>
/// Get Range of Array
/// </summary>
/// <param name="array"></param>
/// <param name="offset"></param>
/// <param name="length"></param>
/// <returns></returns>
public byte[] GetSubArray(byte[] array, long offset, long length) public byte[] GetSubArray(byte[] array, long offset, long length)
{ {
byte[] subarray = new byte[length]; byte[] subarray = new byte[length];
@ -112,17 +80,6 @@ namespace NFC.Mifare_DESFire
return subarray; return subarray;
} }
private 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));
}
/// <summary> /// <summary>
/// Check APDU Response for DESFire Error Codes /// Check APDU Response for DESFire Error Codes
/// https://www.nxp.com/docs/en/data-sheet/MF2DLHX0.pdf /// https://www.nxp.com/docs/en/data-sheet/MF2DLHX0.pdf
@ -206,6 +163,35 @@ namespace NFC.Mifare_DESFire
return lastblock; return lastblock;
} }
/// <summary>
/// Expand Array to Block Size, fill with 0x00
/// </summary>
/// <param name="data"></param>
public 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> /// <summary>
/// Rotates Array to the left /// Rotates Array to the left
/// </summary> /// </summary>
@ -310,6 +296,7 @@ namespace NFC.Mifare_DESFire
return c; return c;
} }
/// <summary> /// <summary>
/// Generates SessionKey for DES Authentification /// Generates SessionKey for DES Authentification
/// </summary> /// </summary>
@ -364,62 +351,89 @@ namespace NFC.Mifare_DESFire
return sesssionkey; return sesssionkey;
} }
#endregion
#region Configuration Generator
/// <summary> /// <summary>
/// Set KeyVersion in DES Key /// Genearte KeySetting1 for Application Settings or PICC Setting
/// KeyVersion is stored in LSB of the first 8 Bytes of the DES Key
/// </summary> /// </summary>
public byte[] SetKeyVersion(byte[] key, byte keyversion) public byte GenerateKeySetting1(ChangeApplicationKey changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
{ {
byte[] pow2 = new byte[] return (byte)(((byte)changeKey << 4) | (byte)changeMasterKeySettings | (byte)createDeleteFile | (byte)fileDirectoryAccess | (byte)changeMasterKey);
{
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 ((keyversion & pow2[i]) > 0)
{
new_key[i] = (byte)(new_key[5] | 0x01);
}
else
{
new_key[i] = (byte)(new_key[5] & 0x7F);
}
}
return new_key;
} }
/// <summary> /// <summary>
/// Expand Array to Block Size, fill with 0x00 /// Genearte KeySetting1 for Application Settings or PICC Setting
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="changeKey">ID of Key for changing Application Keys</param>
public byte[] ExpandToBlockSize(byte[] data, uint bocksize) /// <returns></returns>
public byte GenerateKeySetting1(byte changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
{ {
int diff = data.Length % (int)bocksize; if (changeKey < 0x01 || changeKey >= 0x0E)
if (diff == 0)
{ {
return data; 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();
} }
byte[] expand = new byte[data.Length + bocksize - diff]; return (byte)((byte)cryptoOperations | (byte)fileIdentifies | numberOfKeys);
}
data.CopyTo(expand, 0); /// <summary>
/// Generate FileAccess Rights for File Settings
for (int i = expand.Length - 1; i > data.Length - 1; i--) /// 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)
{ {
expand[i] = 0x00; throw new ArgumentOutOfRangeException("One KeyID is not valid");
} }
return expand; return (UInt16)((read << 12) | (write << 8) | (read_write << 4) | configure);
} }
#endregion #endregion
#region DESFire Commands #region DESFire Commands
/// <summary>
/// Format PICC
/// Works after PICC Authentication
/// </summary>
public void Format()
{
_Log.Debug("Start Format");
APDUCommand cmd_format = new APDUCommand(IsoCase.Case2Short)
{
CLA = 0x90,
INS = 0xFC,
};
_Log.DebugFormat("APDU_CMD(cmd_format): {0}", HexConverter.ConvertToHexString(cmd_format.ToArray()));
APDUResponse response = _Card.Transmit(cmd_format);
_Log.DebugFormat("APDU_RES(cmd_format): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response);
_Log.Debug("End Format");
}
/// <summary> /// <summary>
/// Authenticate to PICC, with ISO Authenticate /// Authenticate to PICC, with ISO Authenticate
/// </summary> /// </summary>
@ -443,24 +457,24 @@ namespace NFC.Mifare_DESFire
key_id key_id
} }
}; };
_Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", ConvertToHexString(cmd_challange_request.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", HexConverter.ConvertToHexString(cmd_challange_request.ToArray()));
APDUResponse response = _Card.Transmit(cmd_challange_request); APDUResponse response = _Card.Transmit(cmd_challange_request);
_Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
byte[] rndB_enc = response.Body; byte[] rndB_enc = response.Body;
_Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_enc)); _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_enc));
TDES des = new TDES(); TDES des = new TDES();
byte[] rndB = des.Decrypt(rndB_enc, key, GenerateEmptyKey(8)); byte[] rndB = des.Decrypt(rndB_enc, key, GenerateEmptyArray(8));
_Log.DebugFormat("rndB: {0}", ConvertToHexString(rndB)); _Log.DebugFormat("rndB: {0}", HexConverter.ConvertToHexString(rndB));
rndB.CopyTo(iv, 0); rndB.CopyTo(iv, 0);
byte[] rndB_rl = RotateLeft(rndB); byte[] rndB_rl = RotateLeft(rndB);
_Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_rl)); _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_rl));
if(rndA == null) if(rndA == null)
{ {
@ -468,13 +482,13 @@ namespace NFC.Mifare_DESFire
rndA = new byte[8]; rndA = new byte[8];
rnd.NextBytes(rndA); rnd.NextBytes(rndA);
} }
_Log.DebugFormat("rndA: {0}", ConvertToHexString(rndA)); _Log.DebugFormat("rndA: {0}", HexConverter.ConvertToHexString(rndA));
byte[] rndAB = Concatenate(rndA, rndB_rl); byte[] rndAB = Concatenate(rndA, rndB_rl);
_Log.DebugFormat("rndAB: {0}", ConvertToHexString(rndAB)); _Log.DebugFormat("rndAB: {0}", HexConverter.ConvertToHexString(rndAB));
byte[] rndAB_enc = des.Encrypt(rndAB, key, rndB_enc); byte[] rndAB_enc = des.Encrypt(rndAB, key, rndB_enc);
_Log.DebugFormat("rndA_rndB_enc: {0}", ConvertToHexString(rndAB_enc)); _Log.DebugFormat("rndA_rndB_enc: {0}", HexConverter.ConvertToHexString(rndAB_enc));
iv = ExtractLastBlock(rndAB_enc, 8); iv = ExtractLastBlock(rndAB_enc, 8);
APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
@ -483,21 +497,21 @@ namespace NFC.Mifare_DESFire
INS = 0xAF, INS = 0xAF,
Data = rndAB_enc Data = rndAB_enc
}; };
_Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", HexConverter.ConvertToHexString(cmd_challange_response.ToArray()));
response = _Card.Transmit(cmd_challange_response); response = _Card.Transmit(cmd_challange_response);
_Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", HexConverter.ConvertToHexString(cmd_challange_response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
byte[] encryptedRndAFromCard = response.Body; byte[] encryptedRndAFromCard = response.Body;
_Log.DebugFormat("encryptedRndAFromCard: {0}", ConvertToHexString(encryptedRndAFromCard)); _Log.DebugFormat("encryptedRndAFromCard: {0}", HexConverter.ConvertToHexString(encryptedRndAFromCard));
byte[] rotatedRndAFromCard = des.Decrypt(encryptedRndAFromCard, key, iv); byte[] rotatedRndAFromCard = des.Decrypt(encryptedRndAFromCard, key, iv);
_Log.DebugFormat("rotatedRndAFromCard: {0}", ConvertToHexString(rotatedRndAFromCard)); _Log.DebugFormat("rotatedRndAFromCard: {0}", HexConverter.ConvertToHexString(rotatedRndAFromCard));
byte[] rndAFromCard = RotateRight(rotatedRndAFromCard); byte[] rndAFromCard = RotateRight(rotatedRndAFromCard);
_Log.DebugFormat("rndAFromCard: {0}", ConvertToHexString(rndAFromCard)); _Log.DebugFormat("rndAFromCard: {0}", HexConverter.ConvertToHexString(rndAFromCard));
if (!rndA.SequenceEqual(rndAFromCard)) if (!rndA.SequenceEqual(rndAFromCard))
{ {
@ -505,36 +519,14 @@ namespace NFC.Mifare_DESFire
} }
_SessionKey = GenerateSesionKey_DES(rndA, rndB); _SessionKey = GenerateSesionKey_DES(rndA, rndB);
_Log.DebugFormat("_SessionKey: {0}", ConvertToHexString(_SessionKey)); _Log.DebugFormat("_SessionKey: {0}", HexConverter.ConvertToHexString(_SessionKey));
_IV = GenerateEmptyKey(8); _IV = GenerateEmptyArray(8);
_Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV)); _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
_Log.Debug("End AuthenticateISO_DES"); _Log.Debug("End AuthenticateISO_DES");
} }
/// <summary>
/// Format PICC
/// </summary>
public void Format()
{
_Log.Debug("Start Format");
APDUCommand cmd_format = new APDUCommand(IsoCase.Case2Short)
{
CLA = 0x90,
INS = 0xFC,
};
_Log.DebugFormat("APDU_CMD(cmd_format): {0}", ConvertToHexString(cmd_format.ToArray()));
APDUResponse response = _Card.Transmit(cmd_format);
_Log.DebugFormat("APDU_RES(cmd_format): {0}", ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response);
_Log.Debug("End Format");
}
/// <summary> /// <summary>
/// Create Application for ID /// Create Application for ID
/// </summary> /// </summary>
@ -544,7 +536,7 @@ namespace NFC.Mifare_DESFire
_Log.Debug("Start CreateApplication"); _Log.Debug("Start CreateApplication");
byte[] id_byte = BitConverter.GetBytes(aid); byte[] id_byte = BitConverter.GetBytes(aid);
_Log.DebugFormat("AID: {0}", ConvertToHexString(id_byte.ToArray())); _Log.DebugFormat("AID: {0}", HexConverter.ConvertToHexString(id_byte.ToArray()));
APDUCommand cmd_CreateApplication = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_CreateApplication = new APDUCommand(IsoCase.Case4Short)
{ {
@ -559,10 +551,10 @@ namespace NFC.Mifare_DESFire
keysetting2 keysetting2
} }
}; };
_Log.DebugFormat("APDU_CMD(cmd_CreateApplication): {0}", ConvertToHexString(cmd_CreateApplication.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_CreateApplication): {0}", HexConverter.ConvertToHexString(cmd_CreateApplication.ToArray()));
APDUResponse response = _Card.Transmit(cmd_CreateApplication); APDUResponse response = _Card.Transmit(cmd_CreateApplication);
_Log.DebugFormat("APDU_RES(cmd_CreateApplication): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_CreateApplication): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -578,7 +570,7 @@ namespace NFC.Mifare_DESFire
_Log.Debug("Start SelectApplication"); _Log.Debug("Start SelectApplication");
byte[] id_byte = BitConverter.GetBytes(aid); byte[] id_byte = BitConverter.GetBytes(aid);
_Log.DebugFormat("AID: {0}", ConvertToHexString(id_byte.ToArray())); _Log.DebugFormat("AID: {0}", HexConverter.ConvertToHexString(id_byte.ToArray()));
APDUCommand cmd_SelectApplication = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_SelectApplication = new APDUCommand(IsoCase.Case4Short)
{ {
@ -591,10 +583,10 @@ namespace NFC.Mifare_DESFire
id_byte[2] id_byte[2]
} }
}; };
_Log.DebugFormat("APDU_CMD(cmd_SelectApplication): {0}", ConvertToHexString(cmd_SelectApplication.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_SelectApplication): {0}", HexConverter.ConvertToHexString(cmd_SelectApplication.ToArray()));
APDUResponse response = _Card.Transmit(cmd_SelectApplication); APDUResponse response = _Card.Transmit(cmd_SelectApplication);
_Log.DebugFormat("APDU_RES(cmd_SelectApplication): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_SelectApplication): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -624,24 +616,24 @@ namespace NFC.Mifare_DESFire
key_id key_id
} }
}; };
_Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", ConvertToHexString(cmd_challange_request.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", HexConverter.ConvertToHexString(cmd_challange_request.ToArray()));
APDUResponse response = _Card.Transmit(cmd_challange_request); APDUResponse response = _Card.Transmit(cmd_challange_request);
_Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
byte[] rndB_enc = response.Body; byte[] rndB_enc = response.Body;
_Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_enc)); _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_enc));
AES aes = new AES(); AES aes = new AES();
byte[] rndB = aes.Decrypt(rndB_enc, key, GenerateEmptyKey(16)); byte[] rndB = aes.Decrypt(rndB_enc, key, GenerateEmptyArray(16));
_Log.DebugFormat("rndB: {0}", ConvertToHexString(rndB)); _Log.DebugFormat("rndB: {0}", HexConverter.ConvertToHexString(rndB));
rndB.CopyTo(iv, 0); rndB.CopyTo(iv, 0);
byte[] rndB_rl = RotateLeft(rndB); byte[] rndB_rl = RotateLeft(rndB);
_Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_rl)); _Log.DebugFormat("rndB_enc: {0}", HexConverter.ConvertToHexString(rndB_rl));
if (rndA == null) if (rndA == null)
{ {
@ -649,13 +641,13 @@ namespace NFC.Mifare_DESFire
rndA = new byte[16]; rndA = new byte[16];
rnd.NextBytes(rndA); rnd.NextBytes(rndA);
} }
_Log.DebugFormat("rndA: {0}", ConvertToHexString(rndA)); _Log.DebugFormat("rndA: {0}", HexConverter.ConvertToHexString(rndA));
byte[] rndAB = Concatenate(rndA, rndB_rl); byte[] rndAB = Concatenate(rndA, rndB_rl);
_Log.DebugFormat("rndAB: {0}", ConvertToHexString(rndAB)); _Log.DebugFormat("rndAB: {0}", HexConverter.ConvertToHexString(rndAB));
byte[] rndAB_enc = aes.Encrypt(rndAB, key, rndB_enc); byte[] rndAB_enc = aes.Encrypt(rndAB, key, rndB_enc);
_Log.DebugFormat("rndA_rndB_enc: {0}", ConvertToHexString(rndAB_enc)); _Log.DebugFormat("rndA_rndB_enc: {0}", HexConverter.ConvertToHexString(rndAB_enc));
iv = ExtractLastBlock(rndAB_enc, 16); iv = ExtractLastBlock(rndAB_enc, 16);
APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
@ -664,21 +656,21 @@ namespace NFC.Mifare_DESFire
INS = 0xAF, INS = 0xAF,
Data = rndAB_enc Data = rndAB_enc
}; };
_Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", HexConverter.ConvertToHexString(cmd_challange_response.ToArray()));
response = _Card.Transmit(cmd_challange_response); response = _Card.Transmit(cmd_challange_response);
_Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", HexConverter.ConvertToHexString(cmd_challange_response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
byte[] encryptedRndAFromCard = response.Body; byte[] encryptedRndAFromCard = response.Body;
_Log.DebugFormat("encryptedRndAFromCard: {0}", ConvertToHexString(encryptedRndAFromCard)); _Log.DebugFormat("encryptedRndAFromCard: {0}", HexConverter.ConvertToHexString(encryptedRndAFromCard));
byte[] rotatedRndAFromCard = aes.Decrypt(encryptedRndAFromCard, key, iv); byte[] rotatedRndAFromCard = aes.Decrypt(encryptedRndAFromCard, key, iv);
_Log.DebugFormat("rotatedRndAFromCard: {0}", ConvertToHexString(rotatedRndAFromCard)); _Log.DebugFormat("rotatedRndAFromCard: {0}", HexConverter.ConvertToHexString(rotatedRndAFromCard));
byte[] rndAFromCard = RotateRight(rotatedRndAFromCard); byte[] rndAFromCard = RotateRight(rotatedRndAFromCard);
_Log.DebugFormat("rndAFromCard: {0}", ConvertToHexString(rndAFromCard)); _Log.DebugFormat("rndAFromCard: {0}", HexConverter.ConvertToHexString(rndAFromCard));
if (!rndA.SequenceEqual(rndAFromCard)) if (!rndA.SequenceEqual(rndAFromCard))
{ {
@ -686,10 +678,10 @@ namespace NFC.Mifare_DESFire
} }
_SessionKey = GenerateSesionKey_AES(rndA, rndB); _SessionKey = GenerateSesionKey_AES(rndA, rndB);
_Log.DebugFormat("_SessionKey: {0}", ConvertToHexString(_SessionKey)); _Log.DebugFormat("_SessionKey: {0}", HexConverter.ConvertToHexString(_SessionKey));
_IV = GenerateEmptyKey(16); _IV = GenerateEmptyArray(16);
_Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV)); _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
_Log.Debug("End AuthenticateISO_DES"); _Log.Debug("End AuthenticateISO_DES");
} }
@ -708,31 +700,31 @@ namespace NFC.Mifare_DESFire
{ {
0xC4, key_id 0xC4, key_id
}; };
_Log.DebugFormat("header: {0}", ConvertToHexString(header)); _Log.DebugFormat("header: {0}", HexConverter.ConvertToHexString(header));
byte[] key_and_version = new_key; byte[] key_and_version = new_key;
byte[] command = Concatenate(header, key_and_version); byte[] command = Concatenate(header, key_and_version);
_Log.DebugFormat("command: {0}", ConvertToHexString(command)); _Log.DebugFormat("command: {0}", HexConverter.ConvertToHexString(command));
CRC32 crc32 = new CRC32(); CRC32 crc32 = new CRC32();
byte[] crc = crc32.Calculate(command); byte[] crc = crc32.Calculate(command);
_Log.DebugFormat("crc: {0}", ConvertToHexString(crc)); _Log.DebugFormat("crc: {0}", HexConverter.ConvertToHexString(crc));
byte[] cryptogram = Concatenate(key_and_version, crc); byte[] cryptogram = Concatenate(key_and_version, crc);
_Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram)); _Log.DebugFormat("cryptogram: {0}", HexConverter.ConvertToHexString(cryptogram));
byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16); byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
_Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block)); _Log.DebugFormat("cryptogram_block: {0}", HexConverter.ConvertToHexString(cryptogram_block));
TDES des = new TDES(); TDES des = new TDES();
byte[] cryptogram_enc = des.Encrypt(cryptogram_block, _SessionKey, _IV); byte[] cryptogram_enc = des.Encrypt(cryptogram_block, _SessionKey, _IV);
_Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc)); _Log.DebugFormat("cryptogram_enc: {0}", HexConverter.ConvertToHexString(cryptogram_enc));
_IV = ExtractLastBlock(cryptogram_enc, 8); _IV = ExtractLastBlock(cryptogram_enc, 8);
_Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV)); _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc); byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
_Log.DebugFormat("data: {0}", ConvertToHexString(data)); _Log.DebugFormat("data: {0}", HexConverter.ConvertToHexString(data));
APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
{ {
@ -740,10 +732,10 @@ namespace NFC.Mifare_DESFire
INS = 0xC4, INS = 0xC4,
Data = data Data = data
}; };
_Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(cmd_ChangeKey.ToArray()));
APDUResponse response = _Card.Transmit(cmd_ChangeKey); APDUResponse response = _Card.Transmit(cmd_ChangeKey);
_Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -764,32 +756,32 @@ namespace NFC.Mifare_DESFire
{ {
0xC4, key_id 0xC4, key_id
}; };
_Log.DebugFormat("header: {0}", ConvertToHexString(header)); _Log.DebugFormat("header: {0}", HexConverter.ConvertToHexString(header));
// AES Key Version is Append to Key // AES Key Version is Append to Key
byte[] key_and_version = Concatenate(new_key, new byte[] { key_version }); byte[] key_and_version = Concatenate(new_key, new byte[] { key_version });
byte[] command = Concatenate(header, key_and_version); byte[] command = Concatenate(header, key_and_version);
_Log.DebugFormat("command: {0}", ConvertToHexString(command)); _Log.DebugFormat("command: {0}", HexConverter.ConvertToHexString(command));
CRC32 crc32 = new CRC32(); CRC32 crc32 = new CRC32();
byte[] crc = crc32.Calculate(command); byte[] crc = crc32.Calculate(command);
_Log.DebugFormat("crc: {0}", ConvertToHexString(crc)); _Log.DebugFormat("crc: {0}", HexConverter.ConvertToHexString(crc));
byte[] cryptogram = Concatenate(key_and_version, crc); byte[] cryptogram = Concatenate(key_and_version, crc);
_Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram)); _Log.DebugFormat("cryptogram: {0}", HexConverter.ConvertToHexString(cryptogram));
byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16); byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
_Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block)); _Log.DebugFormat("cryptogram_block: {0}", HexConverter.ConvertToHexString(cryptogram_block));
AES aes = new AES(); AES aes = new AES();
byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV); byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
_Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc)); _Log.DebugFormat("cryptogram_enc: {0}", HexConverter.ConvertToHexString(cryptogram_enc));
_IV = ExtractLastBlock(cryptogram_enc, 16); _IV = ExtractLastBlock(cryptogram_enc, 16);
_Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV)); _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc); byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
_Log.DebugFormat("data: {0}", ConvertToHexString(data)); _Log.DebugFormat("data: {0}", HexConverter.ConvertToHexString(data));
APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
{ {
@ -797,10 +789,10 @@ namespace NFC.Mifare_DESFire
INS = 0xC4, INS = 0xC4,
Data = data Data = data
}; };
_Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(cmd_ChangeKey.ToArray()));
APDUResponse response = _Card.Transmit(cmd_ChangeKey); APDUResponse response = _Card.Transmit(cmd_ChangeKey);
_Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -821,37 +813,37 @@ namespace NFC.Mifare_DESFire
{ {
0xC4, key_id 0xC4, key_id
}; };
_Log.DebugFormat("header: {0}", ConvertToHexString(header)); _Log.DebugFormat("header: {0}", HexConverter.ConvertToHexString(header));
byte[] key_xor = XOR(new_key, old_key); byte[] key_xor = XOR(new_key, old_key);
// AES Key Version is Append to Key // AES Key Version is Append to Key
byte[] key_and_version = Concatenate(key_xor, new byte[] { key_version }); byte[] key_and_version = Concatenate(key_xor, new byte[] { key_version });
byte[] command = Concatenate(header, key_and_version); byte[] command = Concatenate(header, key_and_version);
_Log.DebugFormat("command: {0}", ConvertToHexString(command)); _Log.DebugFormat("command: {0}", HexConverter.ConvertToHexString(command));
CRC32 crc32 = new CRC32(); CRC32 crc32 = new CRC32();
byte[] crc_cmd = crc32.Calculate(command); byte[] crc_cmd = crc32.Calculate(command);
_Log.DebugFormat("crc_cmd: {0}", ConvertToHexString(crc_cmd)); _Log.DebugFormat("crc_cmd: {0}", HexConverter.ConvertToHexString(crc_cmd));
byte[] crc_key = crc32.Calculate(new_key); byte[] crc_key = crc32.Calculate(new_key);
_Log.DebugFormat("crc_key: {0}", ConvertToHexString(crc_key)); _Log.DebugFormat("crc_key: {0}", HexConverter.ConvertToHexString(crc_key));
byte[] cryptogram = Concatenate(key_and_version, crc_cmd); byte[] cryptogram = Concatenate(key_and_version, crc_cmd);
cryptogram = Concatenate(cryptogram, crc_key); cryptogram = Concatenate(cryptogram, crc_key);
_Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram)); _Log.DebugFormat("cryptogram: {0}", HexConverter.ConvertToHexString(cryptogram));
byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16); byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
_Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block)); _Log.DebugFormat("cryptogram_block: {0}", HexConverter.ConvertToHexString(cryptogram_block));
AES aes = new AES(); AES aes = new AES();
byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV); byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
_Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc)); _Log.DebugFormat("cryptogram_enc: {0}", HexConverter.ConvertToHexString(cryptogram_enc));
_IV = ExtractLastBlock(cryptogram_enc, 16); _IV = ExtractLastBlock(cryptogram_enc, 16);
_Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV)); _Log.DebugFormat("_IV: {0}", HexConverter.ConvertToHexString(_IV));
byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc); byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
_Log.DebugFormat("data: {0}", ConvertToHexString(data)); _Log.DebugFormat("data: {0}", HexConverter.ConvertToHexString(data));
APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short) APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
{ {
@ -859,10 +851,10 @@ namespace NFC.Mifare_DESFire
INS = 0xC4, INS = 0xC4,
Data = data Data = data
}; };
_Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(cmd_ChangeKey.ToArray()));
APDUResponse response = _Card.Transmit(cmd_ChangeKey); APDUResponse response = _Card.Transmit(cmd_ChangeKey);
_Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -904,10 +896,10 @@ namespace NFC.Mifare_DESFire
INS = (byte)APDUInstructions.CREATE_STDDATAFILE, INS = (byte)APDUInstructions.CREATE_STDDATAFILE,
Data = Concatenate(data, accessRights_byte, size_byte) Data = Concatenate(data, accessRights_byte, size_byte)
}; };
_Log.DebugFormat("APDU_CMD(cmd_CreateFile_Standard): {0}", ConvertToHexString(cmd_CreateFile_Standard.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_CreateFile_Standard): {0}", HexConverter.ConvertToHexString(cmd_CreateFile_Standard.ToArray()));
APDUResponse response = _Card.Transmit(cmd_CreateFile_Standard); APDUResponse response = _Card.Transmit(cmd_CreateFile_Standard);
_Log.DebugFormat("APDU_RES(cmd_CreateFile_Standard): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_CreateFile_Standard): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
@ -924,7 +916,7 @@ namespace NFC.Mifare_DESFire
{ {
_Log.Debug("Start ReadData"); _Log.Debug("Start ReadData");
int max_read_bytes_pre_transaction = 58; int max_read_bytes_pre_transaction = 47;
long bytes_readed = 0; long bytes_readed = 0;
List<byte> read_data = new List<byte>(); List<byte> read_data = new List<byte>();
@ -973,10 +965,10 @@ namespace NFC.Mifare_DESFire
INS = (byte)APDUInstructions.READ_DATA, INS = (byte)APDUInstructions.READ_DATA,
Data = Concatenate(data, offset_byte, length_byte) Data = Concatenate(data, offset_byte, length_byte)
}; };
_Log.DebugFormat("APDU_CMD(cmd_ReadData): {0}", ConvertToHexString(cmd_ReadData.ToArray())); _Log.DebugFormat("APDU_CMD(cmd_ReadData): {0}", HexConverter.ConvertToHexString(cmd_ReadData.ToArray()));
APDUResponse response = _Card.Transmit(cmd_ReadData); APDUResponse response = _Card.Transmit(cmd_ReadData);
_Log.DebugFormat("APDU_RES(cmd_ReadData): {0}", ConvertToHexString(response.ToArray())); _Log.DebugFormat("APDU_RES(cmd_ReadData): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); CheckAPDUResponse(response);
read_data.AddRange(response.Body); read_data.AddRange(response.Body);
@ -996,119 +988,69 @@ namespace NFC.Mifare_DESFire
{ {
_Log.Debug("Start WriteData"); _Log.Debug("Start WriteData");
byte[] file_id_array = new byte[] int max_write_bytes_pre_transaction = 47;
{ byte[] write_buffer;
file_id
};
byte[] offset_byte_tolong = BitConverter.GetBytes(offset); long bytes_writed = 0;
// Use only 3 Bytes long length = data.Length;
byte[] offset_byte = new byte[]
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[0],
offset_byte_tolong[1], offset_byte_tolong[1],
offset_byte_tolong[2], offset_byte_tolong[2],
}; };
byte[] lenght_byte_tolong = BitConverter.GetBytes(data.Length); long bytes_towrite = 0;
// Use only 3 Bytes
byte[] lenght_byte = new byte[]
{
lenght_byte_tolong[0],
lenght_byte_tolong[1],
lenght_byte_tolong[2],
};
APDUCommand cmd_WriteData = new APDUCommand(IsoCase.Case4Short) if (length - bytes_writed < max_write_bytes_pre_transaction)
{ {
CLA = 0x90, bytes_towrite = length - bytes_writed;
INS = (byte)APDUInstructions.WRITE_DATA, }
Data = Concatenate(file_id_array, offset_byte, lenght_byte, data) else
}; {
_Log.DebugFormat("APDU_CMD(cmd_WriteData): {0}", ConvertToHexString(cmd_WriteData.ToArray())); bytes_towrite = max_write_bytes_pre_transaction;
}
APDUResponse response = _Card.Transmit(cmd_WriteData); byte[] length_byte_tolong = BitConverter.GetBytes(bytes_towrite);
_Log.DebugFormat("APDU_RES(cmd_WriteData): {0}", ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response); write_buffer = 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 = (byte)APDUInstructions.WRITE_DATA,
Data = Concatenate(file_id_array, offset_byte, length_byte, write_buffer)
};
_Log.DebugFormat("APDU_CMD(cmd_WriteData): {0}", HexConverter.ConvertToHexString(cmd_WriteData.ToArray()));
APDUResponse response = _Card.Transmit(cmd_WriteData);
_Log.DebugFormat("APDU_RES(cmd_WriteData): {0}", HexConverter.ConvertToHexString(response.ToArray()));
CheckAPDUResponse(response);
}
_Log.Debug("End WriteData"); _Log.Debug("End WriteData");
} }
///// <summary>
///// Write Data to File
///// </summary>
///// <param name="file_id">ID of File (0x01 - 0x10)</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)
//{
// _Log.Debug("Start WriteData");
// int max_write_bytes_pre_transaction = 8;
// 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 = 0;
// 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 = 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 = (byte)APDUInstructions.WRITE_DATA,
// Data = Concatenate(file_id_array, offset_byte, length_byte, write_buffer)
// };
// _Log.DebugFormat("APDU_CMD(cmd_WriteData): {0}", ConvertToHexString(cmd_WriteData.ToArray()));
// APDUResponse response = _Card.Transmit(cmd_WriteData);
// _Log.DebugFormat("APDU_RES(cmd_WriteData): {0}", ConvertToHexString(response.ToArray()));
// CheckAPDUResponse(response);
// }
// _Log.Debug("End WriteData");
//}
/// <summary> /// <summary>
/// Get all ApplicationIDS from PICC /// Get all ApplicationIDS from PICC
/// </summary> /// </summary>
@ -1176,63 +1118,6 @@ namespace NFC.Mifare_DESFire
// CheckAPDUResponse(response); // CheckAPDUResponse(response);
//} //}
#endregion #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(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
#endregion #endregion
} }
} }

4
NFC/Readers/PCSC/Hardware.cs → NFC/Readers/PCSC/PCSC_Hardware.cs
View File

@ -2,7 +2,7 @@
namespace NFC.Readers.PCSC namespace NFC.Readers.PCSC
{ {
public class Hardware : IHardware public class PCSC_Hardware : IHardware
{ {
public string[] GetReaders() public string[] GetReaders()
{ {
@ -27,7 +27,7 @@ namespace NFC.Readers.PCSC
public IReader OpenReader(string readerID) public IReader OpenReader(string readerID)
{ {
return new Reader(readerID); return new PCSC_Reader(readerID);
} }
} }
} }

6
NFC/Readers/PCSC/Reader.cs → NFC/Readers/PCSC/PCSC_Reader.cs
View File

@ -1,13 +1,11 @@
using PCSC; using PCSC;
using PCSC.Iso7816; using PCSC.Iso7816;
using System; using System;
using System.Collections.Generic;
using System.Text;
namespace NFC.Readers.PCSC namespace NFC.Readers.PCSC
{ {
public class Reader : IReader, IDisposable public class PCSC_Reader : IReader, IDisposable
{ {
private string _ReaderID; private string _ReaderID;
private IContextFactory _ContextFactory; private IContextFactory _ContextFactory;
@ -15,7 +13,7 @@ namespace NFC.Readers.PCSC
private IsoReader _ISOReader; private IsoReader _ISOReader;
private ICard _Card; private ICard _Card;
public Reader(string readerID) public PCSC_Reader(string readerID)
{ {
_ReaderID = readerID; _ReaderID = readerID;
} }

16
NFC_Test/Crypto/AES_Test.cs
View File

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

2
NFC_Test/Crypto/CRC16_Test.cs
View File

@ -2,7 +2,7 @@
using NFC.Crypto; using NFC.Crypto;
using NUnit.Framework; using NUnit.Framework;
namespace NFC_Test.Crypto namespace NFC_Unit_Test.Crypto
{ {
[TestFixture] [TestFixture]
public class CRC16_Test public class CRC16_Test

2
NFC_Test/Crypto/CRC32_Test.cs
View File

@ -2,7 +2,7 @@
using NFC.Crypto; using NFC.Crypto;
using NUnit.Framework; using NUnit.Framework;
namespace NFC_Test.Crypto namespace NFC_Unit_Test.Crypto
{ {
[TestFixture] [TestFixture]
public class CRC32_Test public class CRC32_Test

13
NFC_Test/Crypto/CipherKey_Test.cs Normal file
View File

@ -0,0 +1,13 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Text;
namespace NFC_Unit_Test.Crypto
{
[TestFixture]
public class CipherKey_Test
{
}
}

36
NFC_Test/Crypto/TDES_Test.cs
View File

@ -1,8 +1,8 @@
using NFC.Crypto; using NFC;
using NFC.Mifare_DESFire; using NFC.Crypto;
using NUnit.Framework; using NUnit.Framework;
namespace NFC_Test.Crypto namespace NFC_Unit_Test.Crypto
{ {
[TestFixture] [TestFixture]
public class TDES_Test public class TDES_Test
@ -11,16 +11,14 @@ namespace NFC_Test.Crypto
[Ignore("Unknown Expected Data")] [Ignore("Unknown Expected Data")]
public void Encrypt_TDES() public void Encrypt_TDES()
{ {
MIFARE_DESFire desfire = new MIFARE_DESFire(null); byte[] data = HexConverter.ConvertFromHexString("");
byte[] key = HexConverter.ConvertFromHexString("");
byte[] data = desfire.ConvertFromHexString(""); byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
byte[] key = desfire.ConvertFromHexString("");
byte[] iv = desfire.ConvertFromHexString("0000000000000000");
TDES des = new TDES(); TDES des = new TDES();
byte[] data_enc = des.Encrypt(data, key, iv); byte[] data_enc = des.Encrypt(data, key, iv);
byte[] data_enc_expected = desfire.ConvertFromHexString(""); byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
Assert.AreEqual(data_enc_expected, data_enc); Assert.AreEqual(data_enc_expected, data_enc);
} }
@ -28,16 +26,14 @@ namespace NFC_Test.Crypto
[Ignore("Unknown Expected Data")] [Ignore("Unknown Expected Data")]
public void Encrypt_TDES_2K() public void Encrypt_TDES_2K()
{ {
MIFARE_DESFire desfire = new MIFARE_DESFire(null); byte[] data = HexConverter.ConvertFromHexString("");
byte[] key = HexConverter.ConvertFromHexString("");
byte[] data = desfire.ConvertFromHexString(""); byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
byte[] key = desfire.ConvertFromHexString("");
byte[] iv = desfire.ConvertFromHexString("0000000000000000");
TDES_2K des = new TDES_2K(); TDES_2K des = new TDES_2K();
byte[] data_enc = des.Encrypt(data, key, iv); byte[] data_enc = des.Encrypt(data, key, iv);
byte[] data_enc_expected = desfire.ConvertFromHexString(""); byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
Assert.AreEqual(data_enc_expected, data_enc); Assert.AreEqual(data_enc_expected, data_enc);
} }
@ -45,16 +41,14 @@ namespace NFC_Test.Crypto
[Ignore("Unknown Expected Data")] [Ignore("Unknown Expected Data")]
public void Encrypt_TDES_3K() public void Encrypt_TDES_3K()
{ {
MIFARE_DESFire desfire = new MIFARE_DESFire(null); byte[] data = HexConverter.ConvertFromHexString("");
byte[] key = HexConverter.ConvertFromHexString("");
byte[] data = desfire.ConvertFromHexString(""); byte[] iv = HexConverter.ConvertFromHexString("0000000000000000");
byte[] key = desfire.ConvertFromHexString("");
byte[] iv = desfire.ConvertFromHexString("0000000000000000");
TDES_3K des = new TDES_3K(); TDES_3K des = new TDES_3K();
byte[] data_enc = des.Encrypt(data, key, iv); byte[] data_enc = des.Encrypt(data, key, iv);
byte[] data_enc_expected = desfire.ConvertFromHexString(""); byte[] data_enc_expected = HexConverter.ConvertFromHexString("");
Assert.AreEqual(data_enc_expected, data_enc); Assert.AreEqual(data_enc_expected, data_enc);
} }
} }

2
NFC_Test/HexConverter_Test.cs
View File

@ -1,7 +1,7 @@
using NFC; using NFC;
using NUnit.Framework; using NUnit.Framework;
namespace NFC_Test namespace NFC_Unit_Test
{ {
public class HexConverter_Test public class HexConverter_Test
{ {

2
NFC_Test/ISO7816-4/APDUCommand_Test.cs
View File

@ -3,7 +3,7 @@ using NFC.ISO7816_4;
using NUnit.Framework; using NUnit.Framework;
using PCSC.Iso7816; using PCSC.Iso7816;
namespace NFC_Test.ISO7816_4 namespace NFC_Unit_Test.ISO7816_4
{ {
[TestFixture] [TestFixture]
public class APDUCommand_Test public class APDUCommand_Test

308
NFC_Test/NXP MIFARE DESFire/Command_Card_Test.cs
View File

@ -1,308 +0,0 @@
using NFC;
using NFC.Crypto;
using NFC.Mifare_DESFire;
using NFC.Readers.PCSC;
using NUnit.Framework;
using NUnit.Framework.Constraints;
using System;
using System.Collections.Generic;
using System.Text;
namespace NFC_Test.NXP_MIFARE_DESFire
{
/// <summary>
/// Test all DESFire Commands with empty Card
/// </summary>
[Description("Test with real DESFire Card")]
[Explicit]
public class Command_Card_Test
{
public readonly string ReaderID = "";
public readonly UInt32 AID = 0xAAFFEE;
public readonly string AES_Key_Master = "25432A462D4A614E645267556B587032";
public readonly string AES_Key_1 = "50645367566B59703373367638792F42";
/// <summary>
/// Get ReaderIDs form PC/SC API
/// </summary>
[Test]
public void GetReaderIDs()
{
IHardware hardware = new Hardware();
string[] readers = hardware.GetReaders();
Console.WriteLine("Readers detected: {0}", readers.Length);
if (readers.Length > 0)
{
Console.WriteLine("List of ReaderIDs:");
foreach (string readerID in readers)
{
Console.WriteLine("{0}", readerID);
}
}
}
[Test]
public void Connect()
{
IHardware hardware = new Hardware();
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;
}
[Test]
public void Format()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.Format();
test_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, test_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
[Test]
public void SelectApplication()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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]
public void Authenticate_DES()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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]
public void CreateApplication()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
CipherKey key = new CipherKey(CipherType.TDES);
desfire.AuthenticateISO_DES(0x00, key._Key);
byte keysetting1 = desfire.GenerateKeySetting1(NFC.Mifare_DESFire.Enums.ChangeApplicationKey.ALLKEYS, NFC.Mifare_DESFire.Enums.ChangeMasterKeySettings.WITHMASTERKEY, NFC.Mifare_DESFire.Enums.CreateDeleteFile.NOKEY, NFC.Mifare_DESFire.Enums.FileDirectoryAccess.NOKEY, NFC.Mifare_DESFire.Enums.ChangeMasterKey.CHANGEABLE);
byte keysetting2 = desfire.GenerateKeySetting2(NFC.Mifare_DESFire.Enums.CryptoOperationsType.AES, NFC.Mifare_DESFire.Enums.FileIdentifies.NOTUSED, 2);
desfire.CreateApplication(AID, keysetting1, keysetting2);
test_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, test_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
[Test]
public void Authenticate_AES()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(AID);
CipherKey key = new CipherKey(CipherType.AES);
desfire.AuthenticateISO_AES(0x00, key._Key);
test_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, test_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
[Test]
public void ChangeApplicationMasterKey()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(AID);
CipherKey key_default = new CipherKey(CipherType.AES);
desfire.AuthenticateISO_AES(0x00, key_default._Key);
CipherKey key = new CipherKey(AES_Key_Master, CipherType.AES, 0x10);
desfire.ChangeKey_AES(0x00, key._Key, key._KeyVersion);
test_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, test_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
[Test]
public void ChangeApplicationKey_1()
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(AID);
CipherKey key_master = new CipherKey(AES_Key_Master, CipherType.AES, 0x10);
desfire.AuthenticateISO_AES(0x00, key_master._Key);
CipherKey key_old = new CipherKey(AES_Key_1, CipherType.AES, 0x10);
CipherKey key_new = new CipherKey(AES_Key_1, CipherType.AES, 0x10);
desfire.ChangeOtherKey_AES(0x01, key_new._Key, key_old._Key, key_new._KeyVersion);
test_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, test_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
}
}

10
NFC_Test/NXP MIFARE DESFire/Command_Test.cs
View File

@ -1,10 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace NFC_Test.NXP_MIFARE_DESFire
{
class Command_Test
{
}
}

193
NFC_Test/NXP MIFARE DESFire/MIFARE_DESFire_Test.cs
View File

@ -1,4 +1,5 @@
using NFC; using NFC;
using NFC.Mifare_DESFire.Enums;
using NFC.ISO7816_4; using NFC.ISO7816_4;
using NFC.Mifare_DESFire; using NFC.Mifare_DESFire;
using NFC.NXP_MIFARE_DESFire.Exceptions; using NFC.NXP_MIFARE_DESFire.Exceptions;
@ -6,30 +7,48 @@ using NSubstitute;
using NUnit.Framework; using NUnit.Framework;
using System; using System;
namespace NFC_Test.NXP_MIFARE_DESFire namespace NFC_Unit_Test.NXP_MIFARE_DESFire
{ {
[TestFixture] [TestFixture]
public class MIFARE_DESFire_Test public class MIFARE_DESFire_Test
{ {
#region Helper Methods #region Helper Methods
[Test] [Test]
public void GenerateDefaultKey() public void GenerateEmptyArray()
{ {
uint i = 16; uint i = 16;
MIFARE_DESFire desfire = new MIFARE_DESFire(null); MIFARE_DESFire desfire = new MIFARE_DESFire(null);
byte[] data = desfire.GenerateEmptyKey(i); byte[] data = desfire.GenerateEmptyArray(i);
for(int e = 0; e < i; e++) for (int e = 0; e < i; e++)
{ {
if(data[e] != 0x00) if (data[e] != 0x00)
{ {
Assert.Fail("Data is not 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
};
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(expected_subarray, desfire.GetSubArray(array, 1, 3));
}
[Test] [Test]
public void CheckAPDUResponse__NULL() public void CheckAPDUResponse__NULL()
{ {
@ -175,7 +194,6 @@ namespace NFC_Test.NXP_MIFARE_DESFire
}); });
} }
[Test] [Test]
public void CheckAPDUResponse__PARAMETER_ERROR() public void CheckAPDUResponse__PARAMETER_ERROR()
{ {
@ -194,7 +212,6 @@ namespace NFC_Test.NXP_MIFARE_DESFire
}); });
} }
[Test] [Test]
public void CheckAPDUResponse__AUTHENTICATION_DELAY() public void CheckAPDUResponse__AUTHENTICATION_DELAY()
{ {
@ -370,6 +387,40 @@ namespace NFC_Test.NXP_MIFARE_DESFire
}); });
} }
[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
};
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
byte[] lastblock = desfire.ExpandToBlockSize(data, 8);
Assert.AreEqual(expected_lastblock, lastblock);
}
[Test]
public void ExpandToBlockSize_Null()
{
byte[] data = null;
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.Throws<ArgumentNullException>(
delegate
{
byte[] lastblock = desfire.ExpandToBlockSize(data, 8);
});
}
[Test] [Test]
public void RotateLeft() public void RotateLeft()
{ {
@ -538,25 +589,113 @@ namespace NFC_Test.NXP_MIFARE_DESFire
}); });
} }
[Test]
public void GenerateSessionKey_DES()
{
MIFARE_DESFire desfire = new 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] [Test]
public void GenerateSessionKey_AES() public void GenerateSessionKey_AES()
{ {
MIFARE_DESFire desfire = new MIFARE_DESFire(null); MIFARE_DESFire desfire = new MIFARE_DESFire(null);
byte[] rndA = desfire.ConvertFromHexString("bc14dfde20074617e45a8822f06fdd91"); byte[] rndA = HexConverter.ConvertFromHexString("bc14dfde20074617e45a8822f06fdd91");
Console.WriteLine(desfire.ConvertToHexString(rndA)); Console.WriteLine(HexConverter.ConvertToHexString(rndA));
byte[] rndB = desfire.ConvertFromHexString("482ddc54426e6dee560413b8d95471f5"); byte[] rndB = HexConverter.ConvertFromHexString("482ddc54426e6dee560413b8d95471f5");
Console.WriteLine(desfire.ConvertToHexString(rndB)); Console.WriteLine(HexConverter.ConvertToHexString(rndB));
byte[] expected_sessionkey = desfire.ConvertFromHexString("bc14dfde482ddc54f06fdd91d95471f5"); byte[] expected_sessionkey = HexConverter.ConvertFromHexString("bc14dfde482ddc54f06fdd91d95471f5");
Console.WriteLine(desfire.ConvertToHexString(expected_sessionkey)); Console.WriteLine(HexConverter.ConvertToHexString(expected_sessionkey));
byte[] sessionkey = desfire.GenerateSesionKey_AES(rndA, rndB); byte[] sessionkey = desfire.GenerateSesionKey_AES(rndA, rndB);
Console.WriteLine(desfire.ConvertToHexString(sessionkey)); Console.WriteLine(HexConverter.ConvertToHexString(sessionkey));
Assert.AreEqual(expected_sessionkey, sessionkey); Assert.AreEqual(expected_sessionkey, sessionkey);
} }
#endregion #endregion
#region Configuration Generator
[Test]
public void GenerateKeySetting1()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(0x0B, desfire.GenerateKeySetting1(ChangeApplicationKey.MASTERKEY, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE));
}
[Test]
public void GenerateKeySetting1_ChangeKey()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(0x1B, desfire.GenerateKeySetting1(0x01, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE));
}
[Test]
public void GenerateKeySetting1_Wrong_KeyID()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.Throws<ArgumentOutOfRangeException>(
delegate
{
desfire.GenerateKeySetting1(0x10, ChangeMasterKeySettings.WITHMASTERKEY, CreateDeleteFile.ONLYMASTERKEY, FileDirectoryAccess.NOKEY, ChangeMasterKey.CHANGEABLE);
});
}
[Test]
public void GenerateKeySetting2()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(0x82, desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 0x02));
}
[Test]
public void GenerateKeySetting2_Wrong_KeyNumbers()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.Throws<ArgumentOutOfRangeException>(
delegate
{
desfire.GenerateKeySetting2(CryptoOperationsType.AES, FileIdentifies.NOTUSED, 0x10);
});
}
[Test]
public void GenerateFileAccessRights()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(0x1234, desfire.GenerateFileAccessRights(0x01, 0x02, 0x03, 0x04));
}
[Test]
public void GenerateFileAccessRights_OutOfRange()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.Throws<ArgumentOutOfRangeException>(
delegate
{
desfire.GenerateFileAccessRights(0x10, 0x00, 0x00, 0x00);
});
}
#endregion
#region DESFire Commands #region DESFire Commands
[Test] [Test]
public void AuthenticateISO_DES() public void AuthenticateISO_DES()
@ -588,7 +727,7 @@ namespace NFC_Test.NXP_MIFARE_DESFire
desfire.AuthenticateISO_DES(0x00, key, rndA); desfire.AuthenticateISO_DES(0x00, key, rndA);
byte[] expected_sessionkey = HexConverter.ConvertFromHexString("849B36C54FD1B759849B36C54FD1B759"); byte[] expected_sessionkey = HexConverter.ConvertFromHexString("849B36C54FD1B759849B36C54FD1B759");
byte[] expected_iv = desfire.GenerateEmptyKey(8); byte[] expected_iv = HexConverter.ConvertFromHexString("0000000000000000");
Assert.AreEqual(expected_sessionkey, desfire._SessionKey); Assert.AreEqual(expected_sessionkey, desfire._SessionKey);
Assert.AreEqual(expected_iv, desfire._IV); Assert.AreEqual(expected_iv, desfire._IV);
@ -624,7 +763,7 @@ namespace NFC_Test.NXP_MIFARE_DESFire
desfire.AuthenticateISO_AES(0x00, key, rndA); desfire.AuthenticateISO_AES(0x00, key, rndA);
byte[] expected_sessionkey = HexConverter.ConvertFromHexString("8a8b3c15c71d0cf46aead1f148f27703"); byte[] expected_sessionkey = HexConverter.ConvertFromHexString("8a8b3c15c71d0cf46aead1f148f27703");
byte[] expected_iv = desfire.GenerateEmptyKey(16); byte[] expected_iv = HexConverter.ConvertFromHexString("00000000000000000000000000000000");
Assert.AreEqual(expected_sessionkey, desfire._SessionKey); Assert.AreEqual(expected_sessionkey, desfire._SessionKey);
Assert.AreEqual(expected_iv, desfire._IV); Assert.AreEqual(expected_iv, desfire._IV);
@ -683,27 +822,5 @@ namespace NFC_Test.NXP_MIFARE_DESFire
desfire.ChangeOtherKey_AES(0x01, new_key, old_key, 0x10); desfire.ChangeOtherKey_AES(0x01, new_key, old_key, 0x10);
} }
#endregion #endregion
#region Configuration Generator
[Test]
public void GenerateFileAccessRights()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.AreEqual(0x1234, desfire.GenerateFileAccessRights(0x01, 0x02, 0x03, 0x04));
}
[Test]
public void GenerateFileAccessRights_OutOfRange()
{
MIFARE_DESFire desfire = new MIFARE_DESFire(null);
Assert.Throws<ArgumentOutOfRangeException>(
delegate
{
desfire.GenerateFileAccessRights(0x10, 0x00, 0x00, 0x00);
});
}
#endregion
} }
} }

21
NFC_Test/NamespaceSetUp.cs
View File

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

477
NFC_Test/REAL_DESFireCommands.cs Normal file
View File

@ -0,0 +1,477 @@
using NFC;
using NFC.Crypto;
using NFC.Mifare_DESFire;
using NFC.Mifare_DESFire.Enums;
using NFC.Readers.PCSC;
using NUnit.Framework;
using System;
using System.Text;
namespace NFC_Real_Test
{
/// <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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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._Key, key._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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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 PCSC_Hardware();
IReader reader = hardware.OpenReader(ReaderID);
bool test_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new 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;
}
}
}

37
NFC_Test/FabAccess_OTA.cs → NFC_Test/REAL_FabAccess_OTA.cs
View File

@ -6,13 +6,11 @@ using NFC.Mifare_DESFire.Enums;
using System; using System;
using System.Text; using System.Text;
using NFC.Crypto; using NFC.Crypto;
using System.Runtime.CompilerServices;
using System.Drawing.Printing;
namespace NFC_Test namespace NFC_Real_Test
{ {
[TestFixture, Explicit] [TestFixture, Explicit]
public class FabAccess_OTA public class REAL_FabAccess_OTA
{ {
private string _ReaderID = "ACS ACR122U PICC Interface 0"; private string _ReaderID = "ACS ACR122U PICC Interface 0";
private UInt32 _FabAccess_AID = 0x2A472D; private UInt32 _FabAccess_AID = 0x2A472D;
@ -23,16 +21,19 @@ namespace NFC_Test
private CipherKey _FabAccess_Application_MasterKey = new CipherKey("50645367566B59703273357638792F42", 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 CipherKey _FabAccess_Application_AuthKey = new CipherKey("6D5A7134743677397A24432646294A40", CipherType.AES, 0x10);
private string _FabAccess_UserDomain = "thejoklla@fvm.fab-access.org"; private string _FabAccess_UserDomain = "verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylooooooooooooooooooongusssssssssssssssssssssssernaaaaaaaaaaaaaaaaaaaaaaaame@fvm.fab-access.org";
private string _FabAccess_Domain = "fvm.fab-access.org"; private string _FabAccess_Domain = "fvm.fab-access.org";
private CipherKey _Default_DESKey = new CipherKey(CipherType.TDES); private CipherKey _Default_DESKey = new CipherKey(CipherType.TDES);
private CipherKey _Default_AESKey = new CipherKey(CipherType.AES); private CipherKey _Default_AESKey = new CipherKey(CipherType.AES);
[Test] /// <summary>
/// Create FabAccess Application and UserData File
/// </summary>
[Test, Order(1)]
public void Init_EmptyCard() public void Init_EmptyCard()
{ {
IHardware hardware = new Hardware(); IHardware hardware = new PCSC_Hardware();
IReader reader = hardware.OpenReader(_ReaderID); IReader reader = hardware.OpenReader(_ReaderID);
bool transmit_successfully = false; bool transmit_successfully = false;
@ -54,7 +55,7 @@ namespace NFC_Test
desfire.CreateApplication(_FabAccess_AID, keySetting1, keySetting2); desfire.CreateApplication(_FabAccess_AID, keySetting1, keySetting2);
desfire.SelectApplication(_FabAccess_AID); desfire.SelectApplication(_FabAccess_AID);
desfire.AuthenticateISO_AES(0x00, _Default_DESKey._Key); desfire.AuthenticateISO_AES(0x00, _Default_AESKey._Key);
desfire.ChangeKey_AES(0x00, _FabAccess_Application_MasterKey._Key, _FabAccess_Application_MasterKey._KeyVersion); desfire.ChangeKey_AES(0x00, _FabAccess_Application_MasterKey._Key, _FabAccess_Application_MasterKey._KeyVersion);
@ -62,9 +63,9 @@ namespace NFC_Test
desfire.ChangeOtherKey_AES(0x01, _FabAccess_Application_AuthKey._Key, _Default_AESKey._Key, _FabAccess_Application_AuthKey._KeyVersion); 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); UInt16 accesRights = desfire.GenerateFileAccessRights((byte)FileAccessRights.FREE, 0x00, 0x00, 0x00);
desfire.CreateFile_Standard(_FabAccess_FID, FileCommunication.MAC, accesRights, _FabAccess_FSize); desfire.CreateFile_Standard(_FabAccess_FID, FileCommunication.PLAIN, accesRights, _FabAccess_FSize);
desfire.WriteData(0x01, 0, Encoding.ASCII.GetBytes(_FabAccess_UserDomain)); desfire.WriteData(_FabAccess_FID, 0, Encoding.ASCII.GetBytes(_FabAccess_UserDomain));
transmit_successfully = true; transmit_successfully = true;
@ -80,10 +81,13 @@ namespace NFC_Test
reader.CardDiscovered -= handler; reader.CardDiscovered -= handler;
} }
[Test] /// <summary>
/// Authenticate with UserData File and AuthKey
/// </summary>
[Test, Order(2)]
public void Authenticate() public void Authenticate()
{ {
IHardware hardware = new Hardware(); IHardware hardware = new PCSC_Hardware();
IReader reader = hardware.OpenReader(_ReaderID); IReader reader = hardware.OpenReader(_ReaderID);
bool transmit_successfully = false; bool transmit_successfully = false;
@ -95,7 +99,7 @@ namespace NFC_Test
MIFARE_DESFire desfire = new MIFARE_DESFire(card); MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(_FabAccess_AID); desfire.SelectApplication(_FabAccess_AID);
byte[] card_data = desfire.ReadData(_FabAccess_FID, 0x00, 0x0F); byte[] card_data = desfire.ReadData(_FabAccess_FID, 0x00, _FabAccess_FSize);
string userdomain = Encoding.ASCII.GetString(card_data).Replace("\u0000", ""); string userdomain = Encoding.ASCII.GetString(card_data).Replace("\u0000", "");
string domain = userdomain.Split('@')[1]; string domain = userdomain.Split('@')[1];
@ -107,13 +111,6 @@ namespace NFC_Test
desfire.SelectApplication(_FabAccess_AID); desfire.SelectApplication(_FabAccess_AID);
desfire.AuthenticateISO_AES(0x01, _FabAccess_Application_AuthKey._Key); desfire.AuthenticateISO_AES(0x01, _FabAccess_Application_AuthKey._Key);
byte[] card_data_auth = desfire.ReadData(_FabAccess_FID, 0x00, _FabAccess_FSize);
string userdomain_auth = Encoding.ASCII.GetString(card_data).Replace("\u0000", "");
if(card_data_auth != card_data)
{
throw new Exception("Authentication failed");
}
transmit_successfully = true; transmit_successfully = true;
card.Disconnect(); card.Disconnect();

62
NFC_Test/REAL_Reader_PCSC.cs Normal file
View File

@ -0,0 +1,62 @@
using NFC;
using NFC.Readers.PCSC;
using NUnit.Framework;
using System;
namespace NFC_Real_Test
{
[TestFixture, Explicit]
public class REAL_Reader_PCSC
{
/// <summary>
/// Print PCSC ReaderIDs to Console Out
/// </summary>
[Test]
public void GetReaders()
{
IHardware hardware = new PCSC_Hardware();
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 PCSC_Hardware();
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;
}
}
}

129
NFC_Test/REAL_Windows.cs
View File

@ -1,129 +0,0 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Text;
using NFC;
using NFC.Readers.PCSC;
using System.Threading;
using NFC.Mifare_DESFire;
using NFC.Mifare_DESFire.Enums;
using NFC.ISO7816_4;
using PCSC.Iso7816;
using NFC.Crypto;
namespace NFC_Test
{
[TestFixture, Explicit]
public class REAL_Windows
{
[Test]
public void GetReaders()
{
IHardware hardware = new Hardware();
string[] readers = hardware.GetReaders();
Console.WriteLine("Readers detected: {0}", readers.Length);
if(readers.Length > 0)
{
Console.WriteLine("List of ReaderIDs:");
foreach (string readerID in readers)
{
Console.WriteLine("{0}", readerID);
}
}
}
[TestCase("ACS ACR122U PICC Interface 0")]
public void Connect(string readerID)
{
IHardware hardware = new Hardware();
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;
}
[TestCase("ACS ACR122U PICC Interface 0")]
public void Read(string readerID)
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(readerID);
bool connected_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(0x2A472D);
Console.WriteLine(HexConverter.ConvertToHexString(desfire.ReadData(0x01, 0x00, 0xF0)));
connected_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, connected_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
[TestCase("ACS ACR122U PICC Interface 0")]
public void Write(string readerID)
{
IHardware hardware = new Hardware();
IReader reader = hardware.OpenReader(readerID);
bool connected_successfully = false;
ReaderEventHandler handler = (sender, card) =>
{
card.Connect();
MIFARE_DESFire desfire = new MIFARE_DESFire(card);
desfire.SelectApplication(0x2A472D);
CipherKey _FabAccess_Application_MasterKey = new CipherKey("50645367566B59703273357638792F42", CipherType.AES, 0x10);
desfire.AuthenticateISO_AES(0x00, _FabAccess_Application_MasterKey._Key);
desfire.WriteData(0x01, 0x00, HexConverter.ConvertFromHexString("7468656a6f6b6c6c"));
connected_successfully = true;
card.Disconnect();
};
reader.CardDiscovered += handler;
reader.Start();
Assert.AreEqual(true, connected_successfully);
reader.Stop();
reader.CardDiscovered -= handler;
}
}
}

191
NFC_Test/REAL_Windows_CardSetUp.cs
View File

@ -1,191 +0,0 @@
using NFC;
using NFC.Mifare_DESFire;
using NFC.Mifare_DESFire.Enums;
using NFC.Readers.PCSC;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Text;
namespace NFC_Test
{
//[TestFixture]
//public class REAL_Windows_CardSetUp
//{
// public static UInt32 FabAccessAID = 0x001100;
// public static string CardReaderID = "ACS ACR122U PICC Interface 0";
// public static byte[] PICC_MasterKey = new byte[]
// {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// };
// public static byte[] APP_MasterKey = new byte[]
// {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// };
// public static byte[] APP_Key_1 = new byte[]
// {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// };
// public static byte[] APP_Key_2 = new byte[]
// {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// };
// public static byte[] Empty_Key = new byte[]
// {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// };
// public static byte FabAccessIdentFileID = 0x01;
// public static string UserDomain = "user1@fabaccess.org";
// [Test]
// public void ResetCard()
// {
// IHardware hardware = new Hardware();
// IReader reader = hardware.OpenReader(CardReaderID);
// bool connected_successfully = false;
// ReaderEventHandler handler = (sender, card) =>
// {
// card.Connect();
// MIFARE_DESFire mifareDESFire = new MIFARE_DESFire(card);
// mifareDESFire.AuthenticateISO_DES(0x01, PICC_MasterKey);
// mifareDESFire.Format();
// connected_successfully = true;
// card.Disconnect();
// };
// reader.CardDiscovered += handler;
// reader.Start();
// Assert.AreEqual(true, connected_successfully);
// reader.Stop();
// reader.CardDiscovered -= handler;
// }
// [Test]
// public void ProvisionCard()
// {
// IHardware hardware = new Hardware();
// IReader reader = hardware.OpenReader(CardReaderID);
// bool connected_successfully = false;
// ReaderEventHandler handler = (sender, card) =>
// {
// card.Connect();
// MIFARE_DESFire mifareDESFire = new MIFARE_DESFire(card);
// mifareDESFire.AuthenticateISO_DES(0x01, APP_MasterKey);
// mifareDESFire.CreateApplication(FabAccessAID);
// mifareDESFire.SelectApplication(FabAccessAID);
// mifareDESFire.AuthenticateDES(0x00, Empty_Key);
// mifareDESFire.ChangeApplicationMasterKey(APP_MasterKey);
// mifareDESFire.AuthenticateDES(0x00, APP_MasterKey);
// mifareDESFire.ChangeApplicationKey(0x01, APP_Key_1);
// connected_successfully = true;
// card.Disconnect();
// };
// reader.CardDiscovered += handler;
// reader.Start();
// Assert.AreEqual(true, connected_successfully);
// reader.Stop();
// reader.CardDiscovered -= handler;
// }
// [Test]
// public void SetUpUserCard()
// {
// IHardware hardware = new Hardware();
// IReader reader = hardware.OpenReader(CardReaderID);
// bool connected_successfully = false;
// ReaderEventHandler handler = (sender, card) =>
// {
// card.Connect();
// MIFARE_DESFire mifareDESFire = new MIFARE_DESFire(card);
// mifareDESFire.SelectApplication(FabAccessAID);
// mifareDESFire.AuthenticateDES(0x00, Empty_Key);
// UInt16 fileAccessRight = mifareDESFire.GenerateFileAccessRight(AccessRights.FREE, 0x00, 0x00, 0x00);
// mifareDESFire.CreateFile(FabAccessIdentFileID, FileCommunication.PLAIN, fileAccessRight, (UInt32)0x90);
// System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
// mifareDESFire.WirteData(FabAccessIdentFileID, 0x00000000, 0x00000000, enc.GetBytes(UserDomain));
// connected_successfully = true;
// card.Disconnect();
// };
// reader.CardDiscovered += handler;
// reader.Start();
// Assert.AreEqual(true, connected_successfully);
// reader.Stop();
// reader.CardDiscovered -= handler;
// }
// [Test]
// public void AuthenticateCard()
// {
// IHardware hardware = new Hardware();
// IReader reader = hardware.OpenReader(CardReaderID);
// bool connected_successfully = false;
// ReaderEventHandler handler = (sender, card) =>
// {
// card.Connect();
// MIFARE_DESFire mifareDESFire = new MIFARE_DESFire(card);
// mifareDESFire.SelectApplication(FabAccessAID);
// byte[] filedata = mifareDESFire.ReadData(FabAccessIdentFileID, 0x00000000, 0x00000000);
// System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
// string userdomain = enc.GetString(filedata);
// Console.WriteLine(userdomain);
// mifareDESFire.AuthenticateDES(0x01, APP_Key_1);
// connected_successfully = true;
// card.Disconnect();
// };
// reader.CardDiscovered += handler;
// reader.Start();
// Assert.AreEqual(true, connected_successfully);
// reader.Stop();
// reader.CardDiscovered -= handler;
// }
//}
}