/// <summary>
/// Reads the travel card data from HSL Mifare DESFire card.
/// </summary>
/// <param name="card">The card to try to read.</param>
/// <returns>A deserialized Travel Card object if the card was valid, otherwise null.</returns>
public static async Task <TravelCard> ReadTravelCardAsync(SmartCard card)
{
using (SmartCardConnection connection = await card.ConnectAsync())
{
byte[] selection = (await connection.TransmitAsync(HslCommands.SelectHslCommand.AsBuffer())).ToArray();
if (selection != null &&
selection.Length > 0 &&
selection.SequenceEqual(HslCommands.OkResponse))
{
// Travel card info bytes
byte[] appInfo = null;
byte[] periodPass = null;
byte[] storedValue = null;
byte[] eTicket = null;
byte[] history = null;
// Temporary containers for history chunks
byte[] hist1 = new byte[2];
byte[] hist2 = new byte[2];
appInfo = (await connection.TransmitAsync(HslCommands.ReadAppInfoCommand.AsBuffer())).ToArray();
periodPass = (await connection.TransmitAsync(HslCommands.ReadPeriodPassCommand.AsBuffer())).ToArray();
storedValue = (await connection.TransmitAsync(HslCommands.ReadStoredValueCommand.AsBuffer())).ToArray();
eTicket = (await connection.TransmitAsync(HslCommands.ReadETicketCommand.AsBuffer())).ToArray();
hist1 = (await connection.TransmitAsync(HslCommands.ReadHistoryCommand.AsBuffer())).ToArray();
// If we have more history, the last two bytes of the history array will contain the MORE_DATA bytes.
if (hist1.Skip(Math.Max(0, hist1.Length - 2)).ToArray() == HslCommands.MoreData)
{
hist2 = (await connection.TransmitAsync(HslCommands.ReadNextCommand.AsBuffer())).ToArray();
}
// Combine the two history chunks into a single array, minus their last two MORE_DATA bytes
history = hist1.Take(hist1.Length - 2)
.Concat(hist2.Take(hist2.Length - 2)).ToArray();
var rawCard = new RawTravelCard(appInfo, periodPass, storedValue, eTicket, history);
if (rawCard.Status == CardStatus.HslCardDataFailure)
{
return(null);
}
else
{
return(new TravelCard(rawCard));
}
}
else
{
return(null);
}
}
}
protected virtual async void CardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
try
{
card = args.SmartCard;
connection = await card.ConnectAsync();
//Tuple<CardName, DeviceClass> cardType = await DetectCardType();
OnCardPutInField(new EventArgs());
}
catch (Exception ex)
{
LogMessage(ex.Message);
}
}
/// <summary>
/// Click handler for the 'TransmitAPDU' button.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void Transmit_Click(object sender, RoutedEventArgs e)
{
if (!rootPage.ValidateTPMSmartCard())
{
rootPage.NotifyUser("Use Scenario One to create a TPM virtual smart card.", NotifyType.ErrorMessage);
return;
}
Button b = sender as Button;
b.IsEnabled = false;
try
{
SmartCard card = await rootPage.GetSmartCard();
IBuffer result = null;
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Read EF.ATR file
// The command is meant specifically for GIDS cards
// (such as TPM VSCs), and will fail on other types.
byte[] readEfAtrBytes = { 0x00, 0xCB, 0x2F, 0x01, 0x02, 0x5C, 0x00, 0xFF };
IBuffer readEfAtr = CryptographicBuffer.CreateFromByteArray(readEfAtrBytes);
result = await connection.TransmitAsync(readEfAtr);
rootPage.NotifyUser("Response: " + CryptographicBuffer.EncodeToHexString(result), NotifyType.StatusMessage);
}
}
catch (Exception ex)
{
rootPage.NotifyUser("Transmitting APDU to card failed with exception: " + ex.ToString(), NotifyType.ErrorMessage);
}
finally
{
b.IsEnabled = true;
}
}
public async Task ConnectAsync(SmartCard smartcard)
{
_MifareSmartCard = smartcard;
var newConnection = await smartcard.ConnectAsync();
lock (CardConnectionLock)
{
if (_MifareSmartCardConnection != null)
{
_MifareSmartCardConnection.Dispose();
}
_MifareSmartCardConnection = newConnection;
}
mfStdAccess = new Mifare.AccessHandler(_MifareSmartCardConnection);
IccDetection cardIdentification = new IccDetection(_MifareSmartCard, _MifareSmartCardConnection);
await cardIdentification.DetectCardTypeAync();
CurrentCardName = cardIdentification.PcscCardName;
if (!(CurrentCardName == CardName.MifareStandard1K || CurrentCardName == CardName.MifareStandard4K))
{
throw new Mifare.Exceptions.CardTypeException("this Card is not mifare classic card");
}
}
private async void cardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
SmartCard smartCard = args.SmartCard;
try
{
await LogMessageAsync("カードを検知しました", true);
using (SmartCardConnection connection = await smartCard.ConnectAsync())
{
IccDetection cardIdentification = new IccDetection(smartCard, connection);
await cardIdentification.DetectCardTypeAync();
await LogMessageAsync("PC/SCデバイスクラス: " + cardIdentification.PcscDeviceClass.ToString());
await LogMessageAsync("カード名: " + cardIdentification.PcscCardName.ToString());
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == CardName.FeliCa)
{
await LogMessageAsync("FelicaCardがみつかりました");
if (isEDYChecked)
{
await ReadEdyAsync(connection);
}
else
{
await ReadSuicaAsync(connection);
}
}
}
}
catch (Exception ex)
{
await LogMessageAsync("例外が発生: " + ex.ToString());
}
}
public async Task <ISmartCardConnection> Connect()
{
var connection = await _backingSmartCard.ConnectAsync();
return(new UwpSmartCardConnection(connection));
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(connection);
// Each read should get us 16 bytes/4 blocks, so doing
// 4 reads will get us all 64 bytes/16 blocks on the card
for (byte i = 0; i < 4; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
ushort maxAddress = 0;
switch (cardIdentification.PcscCardName)
{
case Pcsc.CardName.MifareStandard1K:
maxAddress = 0x3f;
break;
case Pcsc.CardName.MifareStandard4K:
maxAddress = 0xff;
break;
}
await mfStdAccess.LoadKeyAsync(MifareStandard.DefaultKeys.FactoryDefault);
for (ushort address = 0; address <= maxAddress; address++)
{
var response = await mfStdAccess.ReadAsync(address, Pcsc.GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
private async Task AuthenticateWithSmartCardAsync(SmartCard card)
{
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
String m_selectedDeviceId = localSettings.Values["SelectedDevice"] as String;
string m_selectedDeviceFriendlyName = string.Empty;
string m_selectedDeviceAddDate = string.Empty;
string deviceConfigString = string.Empty;
char[] deviceConfigCharArray;
byte[] deviceIdArray = new byte[16];
byte[] deviceDlockState = new byte[1];
bool foundCompanionDevice = false;
byte[] response = { 0 };
string sw1sw2 = null;
SecondaryAuthenticationFactorAuthenticationStageInfo authStageInfo = await SecondaryAuthenticationFactorAuthentication.GetAuthenticationStageInfoAsync();
if ((authStageInfo.Stage != SecondaryAuthenticationFactorAuthenticationStage.CollectingCredential) && (authStageInfo.Stage != SecondaryAuthenticationFactorAuthenticationStage.WaitingForUserConfirmation))
{
throw new Exception("Unexpected! Stage: " + authStageInfo.Stage);
}
//ShowToastNotification("Post Collecting Credential");
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Post Collecting Credential");
IReadOnlyList <SecondaryAuthenticationFactorInfo> deviceList = await SecondaryAuthenticationFactorRegistration.FindAllRegisteredDeviceInfoAsync(
SecondaryAuthenticationFactorDeviceFindScope.AllUsers);
if (deviceList.Count == 0)
{
//ShowToastNotification("Unexpected exception, device list = 0");
throw new Exception("Unexpected exception, device list = 0");
}
SmartCardConnection connection = await card.ConnectAsync();
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Connection");
response = await Apdu.TransmitApduAsync(connection, Apdu.getDeviceGuidCmdApdu);
sw1sw2 = Apdu.ApduResponseParser(response, out response);
deviceIdArray = response;
string deviceId = BitConverter.ToString(response).Replace("-", "");
response = await Apdu.TransmitApduAsync(connection, Apdu.getDlockStateCmdApdu);
sw1sw2 = Apdu.ApduResponseParser(response, out response);
deviceDlockState = response;
//string deviceFriendlyName = null;
byte[] deviceConfigDataArray = new byte[18]; //16 bytes for GUID and 1 byte for dLockstate
IBuffer deviceConfigData;
byte[] deviceConfigurationDataArray;
//List<byte[]> deviceConfigList = new List<byte[]>();
foreach (SecondaryAuthenticationFactorInfo device in deviceList)
{
CryptographicBuffer.CopyToByteArray(device.DeviceConfigurationData, out deviceConfigurationDataArray);
//deviceConfigList.Add(deviceConfigurationDataArray);
//deviceFriendlyName = device.DeviceFriendlyName;
if (device.DeviceId == deviceId)
{
m_selectedDeviceId = deviceId;
m_selectedDeviceFriendlyName = device.DeviceFriendlyName;
deviceConfigString = CryptographicBuffer.ConvertBinaryToString(0, device.DeviceConfigurationData);
//deviceConfigCharArray = new char[deviceConfigString.Count()];
//deviceConfigCharArray = deviceConfigString.ToCharArray();
int count = device.DeviceFriendlyName.Count();
m_selectedDeviceAddDate = deviceConfigString.Substring(35 + 1 + count + 1 + 1);
foundCompanionDevice = true;
//continue;
}
}
//Debugger.Break();
if (!foundCompanionDevice)
{
throw new CompanionDeviceNotFoundException();
}
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Start Nonce APDU sending");
response = await Apdu.TransmitApduAsync(connection, Apdu.getNonceCmdApdu);
sw1sw2 = Apdu.ApduResponseParser(response, out response);
if (sw1sw2 != "9000")
{
throw new UnableTogetNonceFromDeviceException();
}
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Nonce APDU recieved without error");
string nonce = BitConverter.ToString(response).Replace("-", "");
IBuffer svcNonce = CryptographicBuffer.DecodeFromHexString(nonce);
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Start Authentication");
SecondaryAuthenticationFactorAuthenticationResult authResult = await SecondaryAuthenticationFactorAuthentication.StartAuthenticationAsync(
m_selectedDeviceId, svcNonce);
if (authResult.Status != SecondaryAuthenticationFactorAuthenticationStatus.Started)
{
//ShowToastNotification("Unexpected! Could not start authentication!");
throw new Exception("Unexpected! Could not start authentication! Status: " + authResult.Status);
}
byte[] devNonce = { 0 };
byte[] svcHmac = { 0 };
byte[] sessNonce = { 0 };
CryptographicBuffer.CopyToByteArray(authResult.Authentication.ServiceAuthenticationHmac, out svcHmac);
CryptographicBuffer.CopyToByteArray(authResult.Authentication.SessionNonce, out sessNonce);
CryptographicBuffer.CopyToByteArray(authResult.Authentication.DeviceNonce, out devNonce);
byte[] cmd = new byte[Apdu.challengeCmdApdu.Length + svcHmac.Length + sessNonce.Length + devNonce.Length];
System.Buffer.BlockCopy(Apdu.challengeCmdApdu, 0, cmd, 0, Apdu.challengeCmdApdu.Length);
System.Buffer.BlockCopy(svcHmac, 0, cmd, Apdu.challengeCmdApdu.Length, svcHmac.Length);
System.Buffer.BlockCopy(sessNonce, 0, cmd, Apdu.challengeCmdApdu.Length + svcHmac.Length, sessNonce.Length);
System.Buffer.BlockCopy(devNonce, 0, cmd, Apdu.challengeCmdApdu.Length + svcHmac.Length + sessNonce.Length, devNonce.Length);
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Send Challenge");
string str = "\"" + m_selectedDeviceFriendlyName + "\"";
await SecondaryAuthenticationFactorAuthentication.ShowNotificationMessageAsync(
str,
SecondaryAuthenticationFactorAuthenticationMessage.DeviceNeedsAttention);
response = await Apdu.TransmitApduAsync(connection, cmd);
sw1sw2 = Apdu.ApduResponseParser(response, out response);
if (sw1sw2 == "6985")
{
throw new UnauthorizedUserException();
}
else if (sw1sw2 == "6984")
{
//ShowToastNotification("Log-in denied by user");
throw new LogInDeniedByUserException();
}
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Response recieved");
byte[] HMACdk = new byte[32];
byte[] HMACsk = new byte[32];
System.Buffer.BlockCopy(response, 0, HMACdk, 0, 32);
System.Buffer.BlockCopy(response, 32, HMACsk, 0, 32);
IBuffer deviceHmac = CryptographicBuffer.CreateFromByteArray(HMACdk);
IBuffer sessionHmac = CryptographicBuffer.CreateFromByteArray(HMACsk);
SecondaryAuthenticationFactorFinishAuthenticationStatus authStatus = await authResult.Authentication.FinishAuthenticationAsync(deviceHmac,
sessionHmac);
if (authStatus != SecondaryAuthenticationFactorFinishAuthenticationStatus.Completed)
{
//ShowToastNotification("Unable to complete authentication!");
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Unable to complete authentication");
throw new Exception("Unable to complete authentication!");
}
deviceConfigString = "";
if (deviceDlockState[0] == 0)
{
deviceConfigString = deviceId + "-0-1-" + m_selectedDeviceFriendlyName + "-" + m_selectedDeviceAddDate;
}
else
{
deviceConfigString = deviceId + "-1-1-" + m_selectedDeviceFriendlyName + "-" + m_selectedDeviceAddDate;
}
deviceConfigCharArray = new char[deviceConfigString.Count()];
deviceConfigString.CopyTo(0, deviceConfigCharArray, 0, deviceConfigString.Count()); // because deviceConfigString is readonly
deviceConfigCharArray[35] = '1'; // to indicate that device was not used for last login
string deviceConfigStringNew = new string(deviceConfigCharArray);
//Debugger.Break();
deviceConfigData = CryptographicBuffer.ConvertStringToBinary(deviceConfigStringNew, 0);
await SecondaryAuthenticationFactorRegistration.UpdateDeviceConfigurationDataAsync(deviceId, deviceConfigData); //update deviceConfigData
foreach (SecondaryAuthenticationFactorInfo device in deviceList)
{
if (device.DeviceId != deviceId)
{
deviceConfigString = CryptographicBuffer.ConvertBinaryToString(0, device.DeviceConfigurationData);
deviceConfigCharArray = new char[deviceConfigString.Count()];
deviceConfigString.CopyTo(0, deviceConfigCharArray, 0, deviceConfigString.Count()); // decause deviceConfigString is readonly
deviceConfigCharArray[35] = '0'; // to indicate that device was not used for last login
deviceConfigStringNew = new string(deviceConfigCharArray);
deviceConfigData = CryptographicBuffer.ConvertStringToBinary(deviceConfigStringNew, 0);
//Debugger.Break();
await SecondaryAuthenticationFactorRegistration.UpdateDeviceConfigurationDataAsync(device.DeviceId, deviceConfigData); //update deviceConfigData
}
}
System.Diagnostics.Debug.WriteLine("[AuthenticateWithSmartCardAsync] Auth completed");
connection.Dispose();
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(connection);
await mifareULAccess.ReadCapsAsync();
if (!mifareULAccess.isNTag21x)
{
var ignored1 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
var msgbox = new Windows.UI.Popups.MessageDialog("This application only works with the NXP NTAG21x line of NFC chips. Sorry.");
msgbox.Commands.Add(new Windows.UI.Popups.UICommand("OK"));
await msgbox.ShowAsync();
});
return;
}
bool authenticated = false;
byte[] password = await ParseField(passwordBox, 4);
byte[] passwordAck = await ParseField(passwordAckBox, 2);
if (password != null && passwordAck != null)
{
try
{
await mifareULAccess.AuthenticateWithPassword(password, passwordAck);
authenticated = true;
}
catch (Exception ex)
{
Debug.WriteLine("Exception sending provisioning password: "******"Exception sending provisioning password: "******"ReadCount: " + responseAccess.ToString());
var ignored2 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
accessCount.Text = responseAccess.ToString();
});
accessCountEnabled = true;
}
catch (Exception ex)
{
Debug.WriteLine("Exception sending Getting Access Count: " + ex);
}
if (!accessCountEnabled)
{
var ignored3 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
accessCount.Text = " ";
accessCountEnable.Visibility = Visibility.Visible;
});
if (autoProvision.IsChecked == true)
{
await mifareULAccess.EnableAccessCountAsync();
}
}
for (byte i = 0; i < mifareULAccess.Blocks; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
for (byte y = 0; y < 4; y++)
{
byte[] buf4 = new byte[4];
Array.Copy(response, y * 4, buf4, 0, 4);
LogMessage((i * 4 + y).ToString("x2") + ": " + BitConverter.ToString(buf4));
}
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
string uidString = BitConverter.ToString(responseUid);
LogMessage("UID: " + uidString);
var ignored4 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
uid.Text = uidString;
UidPanel.Visibility = Visibility.Visible;
});
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception handling card: " + ex.ToString());
}
}
private async Task Initialize()
{
connection = await smartCard.ConnectAsync();
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
//MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(connection);
// Each read should get us 16 bytes/4 blocks, so doing
// 4 reads will get us all 64 bytes/16 blocks on the card
for (byte i = 0; i < 4; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var cyberneticsAccess = new Cybernetics.AccessHandler(connection);
var cardinfo = null as Cybernetics.CardInfo;
var histories = new List <Cybernetics.HistoryInfo>();
var gateHistories = new List <Cybernetics.GateHistoryInfo>();
var sfHistory = null as Cybernetics.SFEntryInfo;
var IDm = await cyberneticsAccess.GetUidAsync(); // ok
LogMessage("IDm: " + BitConverter.ToString(IDm));
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x8B, 0x00 });
var block008B = await cyberneticsAccess.ReadBinaryAsync(0x00);
LogMessage("Card Type: " + BitConverter.ToString(block008B));
cardinfo = Cybernetics.CardInfo.FromBytes(block008B);
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x0F, 0x09 });
for (byte block = 0; block < 20; ++block)
{
var block090F = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("History: " + BitConverter.ToString(block090F));
histories.Add(Cybernetics.HistoryInfo.FromBytes(block090F));
}
var histList = new List <ICHistoryReader.Core.Cybernetics.HistoryInfo>();
var prevHist = null as ICHistoryReader.Core.Cybernetics.HistoryInfo;
foreach (var hist in histories)
{
var h = ICHistoryReader.Core.Cybernetics.HistoryInfo.From(hist, m_stationCodeList);
histList.Add(h);
if (prevHist != null)
{
// 前の履歴から精算額を計算
prevHist.Amount = h.Balance - prevHist.Balance;
}
prevHist = h;
}
histList = histList.SkipLast(1).ToList();
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x8F, 0x10 });
for (byte block = 0; block < 3; ++block)
{
var block108F = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("Gate: " + BitConverter.ToString(block108F));
gateHistories.Add(Cybernetics.GateHistoryInfo.FromBytes(block108F));
}
await cyberneticsAccess.SelectFileAsync(new byte[] { 0xCB, 0x10 });
var temp = new List <byte>();
for (byte block = 0; block < 2; ++block)
{
var block10CB = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("SF: " + BitConverter.ToString(block10CB));
temp.AddRange(block10CB);
}
sfHistory = Cybernetics.SFEntryInfo.FromBytes(temp.ToArray());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
ushort maxAddress = 0;
switch (cardIdentification.PcscCardName)
{
case Pcsc.CardName.MifareStandard1K:
maxAddress = 0x3f;
break;
case Pcsc.CardName.MifareStandard4K:
maxAddress = 0xff;
break;
}
await mfStdAccess.LoadKeyAsync(MifareStandard.DefaultKeys.FactoryDefault);
for (ushort address = 0; address <= maxAddress; address++)
{
var response = await mfStdAccess.ReadAsync(address, Pcsc.GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
var connection = await card.ConnectAsync();
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(connection);
// Each read should get us 16 bytes/4 blocks, so doing
// 4 reads will get us all 64 bytes/16 blocks on the card
for (byte i = 0; i < 4; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
ushort maxAddress = 0;
switch (cardIdentification.PcscCardName)
{
case Pcsc.CardName.MifareStandard1K:
maxAddress = 0x3f;
break;
case Pcsc.CardName.MifareStandard4K:
maxAddress = 0xff;
break;
}
await mfStdAccess.LoadKeyAsync(MifareStandard.DefaultKeys.FactoryDefault);
for (ushort address = 0; address <= maxAddress; address++)
{
var response = await mfStdAccess.ReadAsync(address, Pcsc.GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
connection.Dispose();
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card, SmartCardReader sender)
{
string UID = "";
Int64 id = 0;
try
{
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(connection);
// Each read should get us 16 bytes/4 blocks, so doing
// 4 reads will get us all 64 bytes/16 blocks on the card
for (byte i = 0; i < 4; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
UID = BitConverter.ToString(responseUid);
//await Notify("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
UID = BitConverter.ToString(uid);
//await Notify("UID: " + BitConverter.ToString(uid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
UID = BitConverter.ToString(uid);;
//await Notify("UID: " + BitConverter.ToString(uid));
ushort maxAddress = 0;
switch (cardIdentification.PcscCardName)
{
case Pcsc.CardName.MifareStandard1K:
maxAddress = 0x3f;
break;
case Pcsc.CardName.MifareStandard4K:
maxAddress = 0xff;
break;
}
await mfStdAccess.LoadKeyAsync(MifareStandard.DefaultKeys.FactoryDefault);
for (ushort address = 0; address <= maxAddress; address++)
{
var response = await mfStdAccess.ReadAsync(address, Pcsc.GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
UID = BitConverter.ToString(uid);
//await Notify("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
UID = BitConverter.ToString(apduRes.ResponseData);
}
}
// START MANAGING SUP STOCK
// UID
if (UID != "")
{
id = ToUID(UID);
bool found = false;
int i = 0;
// check if ID is in left list
foreach (var it in AwaySUP)
{
i++;
if (it.IsSameID(id))
{
found = true;
// set price according to dT
int Price = it.GetPrice();
//wait for validation, then move from left to stock
await Notify("! Arrivé, durée = " + it.strTime + " Prix: " + Price + " CHF");
//move from Left to Stock
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here
StockSUP.Add(it);
AwaySUP.Remove(it);
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
);
}
catch (Exception ex)
{
await Notify("Error swapping from away to stock" + ex.ToString());
}
}
}
i = 0;
// check if ID is in stock list
if (!found)
{
foreach (var it in StockSUP)
{
i++;
if (it.IsSameID(id))
{
found = true;
// start time
await Notify("! Valide, près à partir !", "Départ");
i = 0;
it.StartTimer();
//move from stock to left list
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here!
AwaySUP.Add(it);
StockSUP.Remove(it);
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
);
}
catch (Exception ex)
{
await Notify("Error swapping from stock to away" + ex.ToString());
}
}
}
}
// else, adding to stock list
if (!found)
{
if (isNewTagNewSUP)
{
await Notify("! Nouvelle planche ajoutée.");
isNewTagNewSUP = false;
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here!
StockSUP.Add(new SUP(id, SUPCategory[selN]));
}
);
}
catch (Exception ex)
{
await Notify("Error adding to stock" + ex.ToString());
}
showNbStock.Text = StockSUP.Count.ToString();
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
else
{
await Notify("! Cette planche n'est pas répértoriée !");
}
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
//MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
//Connected to card
//LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
//Card name
//LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
//If card is "MIFARE DEFIRE" (our case)
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
// Get all data from card
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
// Get UID from object desfire
var UID = BitConverter.ToString(desfire.UID);
//LogMessage(UID, NotifyType.StatusMessage);
ShowToastNotification(UID);
PerformAuthentication();
//LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
ShowToastNotification("Failure getting UID of card, " + apduRes.ToString());
}
else
{
ShowToastNotification("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
ShowToastNotification("Exception handling card: " + ex.ToString());
}
}
