async private void GetDevices()
{
try
{
DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(SmartCardReader.GetDeviceSelector(SmartCardReaderKind.Nfc));
// There is a bug on some devices that were updated to WP8.1 where an NFC SmartCardReader is
// enumerated despite that the device does not support it. As a workaround, we can do an additonal check
// to ensure the device truly does support it.
var workaroundDetect = await DeviceInformation.FindAllAsync("System.Devices.InterfaceClassGuid:=\"{50DD5230-BA8A-11D1-BF5D-0000F805F530}\" AND System.Devices.InterfaceEnabled:=System.StructuredQueryType.Boolean#True");
if (workaroundDetect.Count == 0 || devices.Count == 0)
{
PopupMessage("No Reader Found!");
}
CardReader = await SmartCardReader.FromIdAsync(devices.First().Id);
MifareCard = new MifareCard(new MifareClassic());
CardReader.CardAdded += CardAdded;
CardReader.CardRemoved += CardRemoved;
}
catch (Exception e)
{
PopupMessage("Exception: " + e.Message);
}
}
private byte[] ReadBlockRange(byte msb, byte blockFrom, byte blockTo)
{
isoReaderInit();
card = new MifareCard(isoReader);
byte i;
var nBlock = 0;
var count = 0;
for (i = blockFrom; i <= blockTo; i++)
{
if ((i + 1) % 4 == 0)
{
continue;
}
nBlock++;
}
var dataOut = new byte[nBlock * 16];
for (i = blockFrom; i <= blockTo; i++)
{
if ((i + 1) % 4 == 0)
{
continue;
}
Array.Copy(ReadBlock(msb, i), 0, dataOut, count * 16, 16);
count++;
}
return(dataOut);
}
private bool WriteBlockRange(byte msb, byte blockFrom, byte blockTo, byte[] data)
{
isoReaderInit();
card = new MifareCard(isoReader);
byte i;
var count = 0;
var blockData = new byte[16];
for (i = blockFrom; i <= blockTo; i++)
{
if ((i + 1) % 4 == 0)
{
continue;
}
Array.Copy(data, count * 16, blockData, 0, 16);
if (WriteBlock(msb, i, blockData))
{
count++;
}
else
{
return(false);
}
}
return(true);
}
public string ReadCardSerialNumber()
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
try
{
if (reader != null)
{
if (reader.Connect())
{
if (reader.RequestCardSerial(card))
{
SetCardSerialNumber(card.GetCardSerial());
reader.Disconnect();
return(GetCardSerialNumber());
}
throw new Exception("Card not found");
}
throw new Exception("Device not found");
}
throw new Exception("Device not found");
}
catch (Exception)
{
reader.Disconnect();
throw;
}
finally
{
reader.Disconnect();
}
}
public bool ReadAllData_MifareClassic_ZXPSeries9(ref string data)
{
try
{
Debug.WriteLine("starting ReadAllData_MifareClassic_ZXPSeries9...");
// get list blocks will be read/write
List <MifareCard_Block> lstBlocks = GetAll_Blocks_MifareClassic(EnumSmartCardTypes.MifareClassic4K);
if (lstBlocks == null || lstBlocks.Count() == 0)
{
throw new Exception("Can not get card blocks");
}
// MSB
byte MSB = 0x60;
// Create card
MifareCard card = CreateMifareCardInstance(MSB);
if (card == null)
{
throw new Exception("Can not create card instance with keys: " + BitConverter.ToString(_authenticationKeys));
}
// loop all blocks read/write to read binary data
StringBuilder sbData = new StringBuilder();
foreach (var block in lstBlocks)
{
// authentication
// typeB
bool authSuccessful = card.Authenticate(MSB, block.Block_Index_Hex, KeyType.KeyA, 0x00);
if (!authSuccessful)
{
throw new Exception("AUTHENTICATE failed at block " + block.Block_Index_Dec + " with key " + BitConverter.ToString(_authenticationKeys));
//Debug.WriteLine("AUTHENTICATE failed at block " + block.Block_Index_Sector_Dec + " with key " + BitConverter.ToString(authenticationKeys));
//continue;
}
// get data
byte[] result = card.ReadBinary(MSB, block.Block_Index_Hex, 16);
// display data writen
string datastring = (result != null) ? Encoding.UTF8.GetString(result) : string.Empty;
string dateBit = (result != null) ? BitConverter.ToString(result) : string.Empty;
sbData.AppendLine($"Block {block.Block_Index_Hex}: " + dateBit);
}
// return value
data = sbData.ToString();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine("ReadAllData_MifareClassic exception: " + ex.ToString());
return(false);
}
}
public StatusCode WriteBlock(int sector, int block, string data, string key, byte authentication_mode)
{
var MifareCard = new MifareCard(MifareCardTypes.Mifare4k);
bool WriteStatus = true;
try
{
if (reader != null)
{
if (reader.Connect())
{
if (authentication_mode == AuthenticationMode.KeyA)
{
MifareCard.SetKeyA(key, sector);
MifareCard.SetAuthenticationMode(0);
}
else
{
MifareCard.SetKeyB(key, sector);
MifareCard.SetAuthenticationMode(1);
}
reader.RequestCardSerial(MifareCard);
string SecuredData = AddSecurityBytes(MifareCard.GetCardSerial(), data);
WriteStatus = reader.WriteBlock(MifareCard, AddTrailingBits(ConvertStringToHex(SecuredData)), sector, block);
if (!WriteStatus)
{
reader.Disconnect();
return(StatusCode.ErrIncorrectKey);
}
reader.Disconnect();
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
return(StatusCode.Success);
}
catch (Exception)
{
reader.Disconnect();
throw;
}
}
public StatusCode EraseBlock(string data, int sector, int block, string key, byte authentication_mode)
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
bool WriteStatus = true;
try
{
if (reader != null)
{
if (reader.Connect())
{
if (authentication_mode == AuthenticationMode.KeyA)
{
card.SetKeyA(key, sector);
card.SetAuthenticationMode(0);
}
else
{
card.SetKeyB(key, sector);
card.SetAuthenticationMode(1);
}
WriteStatus = reader.WriteBlock(card, data, sector, block);
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
if (WriteStatus)
{
return(StatusCode.Success);
}
return(StatusCode.ErrIncorrectKey);
}
catch (Exception)
{
throw;
}
finally
{
reader.Disconnect();
}
}
private void BtnInitialize_Click(object sender, EventArgs e)
{
byte[] key = HexString.FromHexString(this.AuthenKey.Text.Trim(), "-");
M1KeyMode keyMode = (M1KeyMode)Enum.Parse(typeof(M1KeyMode), AuthenKeyType.Items[AuthenKeyType.SelectedIndex] as String, true);
ICard card = new MifareCard(
ContextManager.GetLogger(),
//ConfigManager.GetKeyService(),
null,
ContextManager.GetCardReader(),
keyMode,
key);
card.Initialize(ContextManager.GetCardTemplete().SegmentAddr);
}
public Pedestrian(Login home)
{
InitializeComponent();
this.home = home;
this.restApi = new RESTAPI();
this.database = new DBConnect();
this.bni = new BNI();
this.mifareCard = new MifareCard(this);
this.mifareCard.RunMain();
InitData();
InitializePedestrianType();
}
public void Initialize()
{
InitializeVehicleType();
CameraHelper.StartIpCamera(liveCamera);
this.webcamImage = webcam;
if (Properties.Settings.Default.WebcamEnabled)
{
this.camera = new Webcam(this);
}
nonCash.Checked = true;
this.restApi = new RESTAPI();
this.database = new DBConnect();
this.bni = new BNI();
this.mifareCard = new MifareCard(this);
this.mifareCard.RunMain();
}
private void Initialize()
{
this.webcamImage = webcam;
this.camera = new Webcam(this);
this.restApi = new RESTAPI();
this.parkingIn = new ParkingIn();
autoComplete = new AutoCompleteStringCollection();
this.ip_address_server = Properties.Settings.Default.IPAddressServer;
StartLiveCamera();
this.MifareCard = new MifareCard(this);
this.MifareCard.RunMain();
InitDataVehicleType();
}
public StatusCode WriteKeys(string[] keyA, string[] keyB)
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
bool WriteStatus = true;
try
{
if (reader != null)
{
if (reader.Connect())
{
for (int i = 1; i < keyA.Length; i++)
{
if (i != 15 && !reader.WriteKeys(card, keyA[i], keyB[i], i, AccessBits.KeyARead_KeyBWrite)) // Skip Cardax Sector
{
throw new Exception("Failed to write keys to sector " + i + ". Hint: Card may not be empty.");
}
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
if (WriteStatus)
{
return(StatusCode.Success);
}
else
{
return(StatusCode.ErrIncorrectKey);
}
}
catch (Exception)
{
throw;
}
finally
{
reader.Disconnect();
}
}
private byte[] ReadBlock(byte msb, byte lsb)
{
isoReaderInit();
card = new MifareCard(isoReader);
var readBinary = new byte[16];
if (card.LoadKey(KeyStructure.VolatileMemory, 0x00, key))
{
if (card.Authenticate(msb, lsb, KeyType.KeyA, 0x00))
{
readBinary = card.ReadBinary(msb, lsb, 16);
}
}
return(readBinary);
}
private void Initialize()
{
InitializeVehicleType();
InitializeOutload();
CameraHelper.StartIpCamera(liveCamera);
nonCash.Checked = true;
this.bni = new BNI();
this.webcamImage = webcam;
if (Properties.Settings.Default.WebcamEnabled)
{
this.camera = new Webcam(this);
}
this.mifareCard = new MifareCard(this);
this.mifareCard.RunMain();
}
static void TestMiFareAccess(Pn532 pn532)
{
Span <byte> blockScetor = stackalloc byte[16] {
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xFF,
0x07,
0x80,
0x40,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF
};
var mifare = new MifareCard(pn532, 1);
var access = mifare.SectorTailerAccess(7, blockScetor.ToArray());
var block0 = mifare.BlockAccess(4, blockScetor.ToArray());
var block1 = mifare.BlockAccess(5, blockScetor.ToArray());
var block2 = mifare.BlockAccess(6, blockScetor.ToArray());
Console.WriteLine($"Access: {access}");
Console.WriteLine($"Block0: {block0}");
Console.WriteLine($"Block1: {block1}");
Console.WriteLine($"Block2: {block2}");
//Encode the access
var encodedAccess = mifare.EncodeSectorTailer(access);
var encodedBlock0 = mifare.EncodeSectorTailer(4, block0);
var encodedBlock1 = mifare.EncodeSectorTailer(5, block1);
var encodedBlock2 = mifare.EncodeSectorTailer(6, block2);
byte encoded6 = (byte)(encodedAccess.Item1 | encodedBlock0.Item1 | encodedBlock1.Item1 | encodedBlock2.Item1);
byte encoded7 = (byte)(encodedAccess.Item2 | encodedBlock0.Item2 | encodedBlock1.Item2 | encodedBlock2.Item2);
byte encoded8 = (byte)(encodedAccess.Item3 | encodedBlock0.Item3 | encodedBlock1.Item3 | encodedBlock2.Item3);
// Full function
var encodedFull = mifare.EncodeSectorAndClockTailer(access, new AccessType[] { block0, block1, block2 });
Console.WriteLine($"Original: {blockScetor[6].ToString("X2")} vs encoded: {encoded6.ToString("X2")} vs full: {encodedFull.Item1.ToString("X2")}");
Console.WriteLine($"Original: {blockScetor[7].ToString("X2")} vs encoded: {encoded7.ToString("X2")} vs full: {encodedFull.Item2.ToString("X2")}");
Console.WriteLine($"Original: {blockScetor[8].ToString("X2")} vs encoded: {encoded8.ToString("X2")} vs full: {encodedFull.Item3.ToString("X2")}");
}
public StatusCode ResetDefaultKeys(string[] keyB)
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
try
{
if (reader != null)
{
if (reader.Connect())
{
for (int i = 1; i < keyB.Length; i++)
{
if (i != 15) // Skip Cardax Sector
{
card.SetKeyB(keyB[i], i);
card.SetAuthenticationMode(1);
if (!reader.WriteKeys(card, MifareDefaultKey, MifareDefaultKey, i, AccessBits.Default))
{
throw new Exception("Failed to reset keys to sector " + i + ". Hint: Card may not be SHC card.");
}
}
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
return(StatusCode.Success);
}
catch (Exception)
{
throw;
}
finally
{
reader.Disconnect();
}
}
private void Initialize()
{
this.webcamImage = webcam;
if (Properties.Settings.Default.WebcamEnabled)
{
this.camera = new Webcam(this);
}
this.restApi = new RESTAPI();
this.database = new DBConnect();
this.parkingIn = new ParkingIn();
autoComplete = new AutoCompleteStringCollection();
nonCash.Checked = true;
ip_address_server = Properties.Settings.Default.IPAddressServer;
StartLiveCamera();
this.bni = new BNI();
this.mifareCard = new MifareCard(this);
this.mifareCard.RunMain();
// initialize vehicle type options
try
{
comboBox1.Items.Add("- Pilih Tipe Kendaraan -");
string masterDataFile = TKHelper.GetApplicationExecutableDirectoryName() + Constant.PATH_FILE_MASTER_DATA_PARKING_OUT;
using (StreamReader reader = new StreamReader(masterDataFile))
{
string json = reader.ReadToEnd();
dynamic vehicleTypes = JsonConvert.DeserializeObject(json);
foreach (var types in vehicleTypes["VehicleTypes"])
{
comboBox1.Items.Add(types);
}
comboBox1.SelectedIndex = 0;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
notifyIcon.ShowBalloonTip(Constant.NOTIFICATION_TRAY_TIMEOUT, "Error", Constant.ERROR_MESSAGE_FAIL_TO_FETCH_VEHICLE_TYPE_DATA, ToolTipIcon.Error);
}
}
private void isoReaderInit()
{
try
{
var ctx = contextFactory.Establish(SCardScope.System);
isoReader = new IsoReader(
ctx,
nfcReader,
SCardShareMode.Shared,
SCardProtocol.Any,
false);
card = new MifareCard(isoReader);
}
catch (Exception)
{
//MessageBox.Show(ex.Message, "Info", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private bool WriteBlock(byte msb, byte lsb, byte[] data)
{
isoReaderInit();
card = new MifareCard(isoReader);
if (card.LoadKey(KeyStructure.VolatileMemory, 0x00, key))
{
if (card.Authenticate(msb, lsb, KeyType.KeyA, 0x00))
{
if (card.UpdateBinary(msb, lsb, data))
{
return(true);
}
}
return(false);
}
return(false);
}
public StatusCode ResetDefaultKeys_Sector(string KeyB, int sector)
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
bool WriteStatus = true;
try
{
if (reader != null)
{
if (reader.Connect())
{
card.SetKeyB(KeyB, sector);
card.SetAuthenticationMode(1);
WriteStatus = reader.WriteKeys(card, MifareDefaultKey, MifareDefaultKey, sector, AccessBits.Default);
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
if (WriteStatus)
{
return(StatusCode.Success);
}
return(StatusCode.ErrIncorrectKey);
}
catch (Exception)
{
throw;
}
finally
{
reader.Disconnect();
}
}
public void ClearAllBlock()
{
var res = MessageBox.Show("Apakah anda yakin ingin menghapus data kartu? ", "Warning",
MessageBoxButton.YesNo);
if (res == MessageBoxResult.Yes)
{
isoReaderInit();
card = new MifareCard(isoReader);
var data = new byte[16];
if (card.LoadKey(KeyStructure.VolatileMemory, 0x00, key))
{
for (byte i = 1; i <= 63; i++)
{
if ((i + 1) % 4 == 0)
{
}
else
{
if (card.Authenticate(Msb, i, KeyType.KeyA, 0x00))
{
Array.Clear(data, 0, 16);
if (WriteBlock(Msb, i, data))
{
}
else
{
MessageBox.Show("Data gagal dihapus");
break;
}
}
}
}
MessageBox.Show("Data berhasil dihapus", "Informasi", MessageBoxButton.OK,
MessageBoxImage.Information);
}
}
}
public MainWindow()
{
InitializeComponent();
var contextFactory = ContextFactory.Instance;
var context = contextFactory.Establish(SCardScope.System);
var readerNames = context.GetReaders();
if (NoReaderAvailable(readerNames))
{
MessageBox.Show("Tidak ada reader terdeteksi, periksa kembali koneksi reader anda...", "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
Environment.Exit(0);
}
else
{
var reader = readerNames[0];
if (reader == null)
{
MessageBox.Show("Tidak ada reader terdeteksi, periksa kembali koneksi reader anda...", "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
}
try
{
isoReader = new IsoReader(
context: context,
readerName: reader,
mode: SCardShareMode.Shared,
protocol: SCardProtocol.Any,
releaseContextOnDispose: false);
_card = new MifareCard(isoReader);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public StatusCode WriteKeys_Sector(string KeyA, string KeyB, int sector)
{
var card = new MifareCard(MifareCardTypes.Mifare4k);
bool WriteStatus = true;
try
{
if (reader != null)
{
if (reader.Connect())
{
WriteStatus = reader.WriteKeys(card, KeyA, KeyB, sector, AccessBits.KeyARead_KeyBWrite);
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
}
else
{
return(StatusCode.ErrDeviceNotFound);
}
if (WriteStatus)
{
return(StatusCode.Success);
}
return(StatusCode.ErrIncorrectKey);
}
catch (Exception)
{
throw;
}
finally
{
reader.Disconnect();
}
}
private MifareCard CreateMifareCardInstance(byte MSB, string readerName = null)
{
try
{
if (string.IsNullOrEmpty(readerName))
{
readerName = _readerName;
}
// create card context
var contextFactory = ContextFactory.Instance;
var context = contextFactory.Establish(SCardScope.System);
// create IsoReader
var isoReader = new IsoReader(context, readerName, SCardShareMode.Shared, SCardProtocol.Any, false);
// create mifare card and load authentication keys
MifareCard card = new MifareCard(isoReader);
bool loadKeySuccessful = card.LoadKey(
KeyStructure.VolatileMemory,
MSB,
_authenticationKeys // key
);
// load authentication keys
if (!loadKeySuccessful)
{
throw new Exception("LOAD KEY failed: " + BitConverter.ToString(_authenticationKeys));
}
return(card);
}
catch (Exception ex)
{
Debug.WriteLine("CreateMifareCardInstance_Printer" + ex.ToString());
return(null);
}
}
static void ChangePermissions(Pn532 pn532, MifareCard mifareCard)
{
// keep permsissions of sector 0-3 and change the one from sector 4-63
// Change the key B to default FF FF FF FF FF FF
var newKey = new byte[6] {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
for (byte i = 7; i < 64; i += 4)
{
mifareCard.BlockNumber = i;
mifareCard.Command = MifareCardCommand.AuthenticationA;
var ret = mifareCard.RunMifiCardCommand();
if (ret >= 0)
{
mifareCard.BlockNumber = i;
mifareCard.Command = MifareCardCommand.Read16Bytes;
ret = mifareCard.RunMifiCardCommand();
if (ret >= 0)
{
//var access = AccessType.ReadKeyA | AccessType.ReadKeyB | AccessType.WriteKeyA | AccessType.WriteKeyB | AccessType.IncrementKeyA | AccessType.IncrementKeyB | AccessType.DecrementTransferRestoreKeyA | AccessType.DecrementTransferRestoreKeyB;
//var sector = AccessSector.KeyAWriteKeyA | AccessSector.AccessBitsReadKeyA | AccessSector.KeyBWriteKeyA | AccessSector.KeyBRead | AccessSector.KeyBReadKeyA;
//var accessNew = new AccessType[3] { access, access, access };
//var encoded = mifareCard.EncodeSectorAndClockTailer(sector, accessNew);
//Console.WriteLine($"{encoded.Item1}, {encoded.Item2}, {encoded.Item3}");
mifareCard.Data[6] = 0xFF; //encoded.Item1;
mifareCard.Data[7] = 0x07; //encoded.Item2;
mifareCard.Data[8] = 0x80; // encoded.Item3;
mifareCard.Command = MifareCardCommand.Write16Bytes;
ret = mifareCard.RunMifiCardCommand();
if (ret >= 0)
{
Console.WriteLine("permossion changed");
}
}
}
}
}
public bool VerifyCard(MifareCard Card)
{
string data = ConvertHexToString(Card.GetDataFromLastBlockRead());
string MifareID = Card.GetCardSerial();
if (data.Length > 0)
{
string SecurityString = EncryptOrDecrypt(data.Substring(0, 4), "schc");
if (SecurityString.Equals(MifareID.Substring(MifareID.Length - 4, 4)))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
private bool VerifyCardAuthentication(MifareCard card, byte MSB, List <MifareCard_Block> lstBlocks)
{
try
{
bool authSuccessful = true;
foreach (var block in lstBlocks)
{
// authentication, typeA for classic 4K
authSuccessful = card.Authenticate(MSB, block.Block_Index_Hex, KeyType.KeyB, 0x00);
if (!authSuccessful)
{
throw new Exception("AUTHENTICATE failed at block " + block.Block_Index_Dec + " with key " + BitConverter.ToString(_authenticationKeys));
}
}
return(authSuccessful);
}
catch (Exception ex)
{
Debug.WriteLine("VerifyCardAuthentication exception: " + ex.ToString());
return(false);
}
}
public static void WriteCode()
{
// Creating the device class through serial: /dev/ttyS0
try
{
string device = "/dev/ttyS0";
var reader = new Pn532(device);
byte[] writeUser = null;
writeUser = reader.ListPassiveTarget(MaxTarget.One, TargetBaudRate.B106kbpsTypeA);
Thread.Sleep(200);
do
{
var decrypted = reader.TryDecode106kbpsTypeA(writeUser.AsSpan().Slice(1));
var uid = BitConverter.ToString(decrypted.NfcId);
Console.WriteLine("Enter Username:");
var userName = Console.ReadLine();
byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(userName);
byte[] cardData = null;
reader.Transceive(1, byteArray, cardData);
MifareCard mifareCard = new MifareCard(reader, decrypted.TargetNumber)
{
BlockNumber = 0, Command = MifareCardCommand.AuthenticationA
};
mifareCard.SetCapacity(decrypted.Atqa, decrypted.Sak);
mifareCard.SerialNumber = decrypted.NfcId;
mifareCard.KeyA = new byte[6] {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
mifareCard.KeyB = new byte[6] {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
for (byte block = 0; block < 1; block++)
{
mifareCard.BlockNumber = block;
mifareCard.Command = MifareCardCommand.AuthenticationB;
var ret = mifareCard.RunMifiCardCommand();
if (ret < 0)
{
// Try another one
mifareCard.Command = MifareCardCommand.AuthenticationA;
ret = mifareCard.RunMifiCardCommand();
}
if (ret == 1)
{
mifareCard.BlockNumber = block;
mifareCard.Command = MifareCardCommand.Write16Bytes;
ret = mifareCard.RunMifiCardCommand();
Console.WriteLine(BitConverter.ToString(cardData));
continue;
}
}
reader.ReleaseTarget(1);
break;
}while(writeUser != null);
}
catch (System.Exception)
{
WriteCode();
}
}
private static void ReadMiFare(Pn532 pn532)
{
byte[] retData = null;
while ((!Console.KeyAvailable))
{
retData = pn532.ListPassiveTarget(MaxTarget.One, TargetBaudRate.B106kbpsTypeA);
if (retData != null)
{
break;
}
// Give time to PN532 to process
Thread.Sleep(200);
}
if (retData == null)
{
return;
}
var decrypted = pn532.TryDecode106kbpsTypeA(retData.AsSpan().Slice(1));
if (decrypted != null)
{
Console.WriteLine(
$"Tg: {decrypted.TargetNumber}, ATQA: {decrypted.Atqa} SAK: {decrypted.Sak}, NFCID: {BitConverter.ToString(decrypted.NfcId)}");
if (decrypted.Ats != null)
{
Console.WriteLine($", ATS: {BitConverter.ToString(decrypted.Ats)}");
}
MifareCard mifareCard = new MifareCard(pn532, decrypted.TargetNumber)
{
BlockNumber = 0, Command = MifareCardCommand.AuthenticationA
};
mifareCard.SetCapacity(decrypted.Atqa, decrypted.Sak);
mifareCard.SerialNumber = decrypted.NfcId;
mifareCard.KeyA = new byte[6] {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
mifareCard.KeyB = new byte[6] {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
for (byte block = 0; block < 64; block++)
{
mifareCard.BlockNumber = block;
mifareCard.Command = MifareCardCommand.AuthenticationB;
var ret = mifareCard.RunMifiCardCommand();
if (ret < 0)
{
// Try another one
mifareCard.Command = MifareCardCommand.AuthenticationA;
ret = mifareCard.RunMifiCardCommand();
}
if (ret >= 0)
{
mifareCard.BlockNumber = block;
mifareCard.Command = MifareCardCommand.Read16Bytes;
ret = mifareCard.RunMifiCardCommand();
if (ret >= 0)
{
Console.WriteLine($"Bloc: {block}, Data: {BitConverter.ToString(mifareCard.Data)}");
}
else
{
Console.WriteLine(
$"Error reading bloc: {block}, Data: {BitConverter.ToString(mifareCard.Data)}");
}
if (block % 4 == 3)
{
// Check what are the permissions
for (byte j = 3; j > 0; j--)
{
var access = mifareCard.BlockAccess((byte)(block - j), mifareCard.Data);
Console.WriteLine($"Bloc: {block - j}, Access: {access}");
}
var sector = mifareCard.SectorTailerAccess(block, mifareCard.Data);
Console.WriteLine($"Bloc: {block}, Access: {sector}");
}
}
else
{
Console.WriteLine($"Autentication error");
}
}
}
}
/// <summary>
/// Override binary data of all blocks of mifare classic 1k
/// </summary>
/// <param name="jsonValue">data to write (json format), maximum 1024 chars for card 1k, 4048 chars for card 4k</param>
/// <returns></returns>
private bool WriteData_MifareClassic(byte[] data, string readerName = null)
{
try
{
if (string.IsNullOrEmpty(readerName))
{
readerName = _readerName;
}
// get list blocks will be read/write
List <MifareCard_Block> lstBlocks = GetAll_Blocks_MifareClassic(EnumSmartCardTypes.MifareClassic4K);
lstBlocks = lstBlocks?.Where(block => block.BlockType == EnumBlockTypes.Data).ToList();
if (lstBlocks == null || lstBlocks.Count() == 0)
{
throw new Exception("Can not get card blocks");
}
// MSB, default for ACS ACR122 0
byte MSB = 0x00;
if (readerName.Equals(EnumDeviceNames.SmartCardPrinterContactlessReader))
{
MSB = 0x60;
}
// create mifare card
MifareCard card = CreateMifareCardInstance(MSB, readerName);
if (card == null)
{
throw new Exception("Can not create card instance with keys: " + BitConverter.ToString(_authenticationKeys));
}
// verify card
//bool verifycationResult = VerifyCardAuthentication(card, MSB, lstBlocks);
//if (!verifycationResult)
//{
// throw new Exception("Authentication failed");
//}
// loop to write binary data to mifare card
int writtenBlock = 0;
int currentSector = -1;
foreach (var block in lstBlocks)
{
if (currentSector != block.Sector_Index)
{
currentSector = block.Sector_Index;
// authentication
// typeB
bool authSuccessful = card.Authenticate(MSB, block.Block_Index_Hex, KeyType.KeyA, 0x00);
if (!authSuccessful)
{
throw new Exception("AUTHENTICATE failed at block " + block.Block_Index_Dec + " with key " + BitConverter.ToString(_authenticationKeys));
}
}
// starting write binary data
byte[] dataToWrite = GetDataToWrite(data, writtenBlock);
var updateSuccessful = card.UpdateBinary(MSB, block.Block_Index_Hex, dataToWrite);
if (!updateSuccessful)
{
throw new Exception("UPDATE BINARY failed at block " + block.Block_Index_Dec + " with value " + BitConverter.ToString(dataToWrite));
}
writtenBlock++;
}
return(true);
}
catch (Exception ex)
{
Debug.WriteLine("WriteBinaryData_MifareClassic exception: " + ex.ToString());
return(false);
}
}
