private void AddTTL(EMVTagMeta tag, KernelDatabaseBase database)
{
if (database.IsNotEmpty(tag.Tag))
{
Children.AddToList(TLV.Create(tag.Tag, database.Get(tag).Value));
}
}
private static bool DoDEKIfNeeded(KernelDatabaseBase database, KernelQ qManager)
{
TLVList toRemove = new TLVList();
foreach (TLV tlv in database.TagsToReadYet)
{
if (database.IsNotEmpty(tlv.Tag.TagLable))
{
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Children.AddToList(tlv);
toRemove.AddToList(tlv);
}
}
foreach (TLV tlv in toRemove)
{
database.TagsToReadYet.RemoveFromList(tlv);
}
if (database.IsNotEmptyList(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2.Tag) && database.TagsToReadYet.Count == 0)
{
CommonRoutines.PostDEK(database, qManager);
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Initialize();
database.Get(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2).Initialize();
return(true);
}
return(false);
}
public static SignalsEnum Execute(
KernelDatabaseBase database,
KernelQ qManager,
CardQ cardQManager
)
{
if (qManager.GetOutputQCount() > 0) //there is a pending request to the terminal
{
KernelRequest kernel1Request = qManager.DequeueFromInput(false);
switch (kernel1Request.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
else
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
switch (cardResponse.CardInterfaceServiceResponseEnum)
{
case CardInterfaceServiceResponseEnum.RA:
return(EntryPointRA(database, qManager));
case CardInterfaceServiceResponseEnum.L1RSP:
return(EntryPointL1RSP(database, qManager, cardResponse));
default:
throw new EMVProtocolException("Invalid Kernel1CardinterfaceServiceResponseEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
public void AddTornTransactionLog(KernelDatabaseBase database)
{
AddTTL(EMVTagsEnum.AMOUNT_AUTHORISED_NUMERIC_9F02_KRN, database);
AddTTL(EMVTagsEnum.AMOUNT_OTHER_NUMERIC_9F03_KRN, database);
AddTTL(EMVTagsEnum.APPLICATION_PRIMARY_ACCOUNT_NUMBER_PAN_5A_KRN, database);
AddTTL(EMVTagsEnum.APPLICATION_PRIMARY_ACCOUNT_NUMBER_PAN_SEQUENCE_NUMBER_5F34_KRN, database);
AddTTL(EMVTagsEnum.BALANCE_READ_BEFORE_GEN_AC_DF8104_KRN2, database);
AddTTL(EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2, database);
AddTTL(EMVTagsEnum.CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN, database);
AddTTL(EMVTagsEnum.DRDOL_RELATED_DATA_DF8113_KRN2, database);
AddTTL(EMVTagsEnum.DS_SUMMARY_1_9F7D_KRN2, database);
AddTTL(EMVTagsEnum.IDS_STATUS_DF8128_KRN2, database);
AddTTL(EMVTagsEnum.INTERFACE_DEVICE_IFD_SERIAL_NUMBER_9F1E_KRN, database);
AddTTL(EMVTagsEnum.PDOL_RELATED_DATA_DF8111_KRN2, database);
AddTTL(EMVTagsEnum.REFERENCE_CONTROL_PARAMETER_DF8114_KRN2, database);
AddTTL(EMVTagsEnum.TERMINAL_CAPABILITIES_9F33_KRN, database);
AddTTL(EMVTagsEnum.TERMINAL_COUNTRY_CODE_9F1A_KRN, database);
AddTTL(EMVTagsEnum.TERMINAL_TYPE_9F35_KRN, database);
AddTTL(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN, database);
AddTTL(EMVTagsEnum.TRANSACTION_CATEGORY_CODE_9F53_KRN2, database);
AddTTL(EMVTagsEnum.TRANSACTION_CURRENCY_CODE_5F2A_KRN, database);
AddTTL(EMVTagsEnum.TRANSACTION_DATE_9A_KRN, database);
AddTTL(EMVTagsEnum.TRANSACTION_TIME_9F21_KRN, database);
AddTTL(EMVTagsEnum.TRANSACTION_TYPE_9C_KRN, database);
AddTTL(EMVTagsEnum.UNPREDICTABLE_NUMBER_9F37_KRN, database);
AddTTL(EMVTagsEnum.TERMINAL_RELAY_RESISTANCE_ENTROPY_DF8301_KRN2, database);
AddTTL(EMVTagsEnum.DEVICE_RELAY_RESISTANCE_ENTROPY_DF8302_KRN2, database);
AddTTL(EMVTagsEnum.MIN_TIME_FOR_PROCESSING_RELAY_RESISTANCE_APDU_DF8303_KRN2, database);
AddTTL(EMVTagsEnum.MAX_TIME_FOR_PROCESSING_RELAY_RESISTANCE_APDU_DF8304_KRN2, database);
AddTTL(EMVTagsEnum.DEVICE_ESTIMATED_TRANSMISSION_TIME_FOR_RELAY_RESISTANCE_RAPDU_DF8305_KRN2, database);
AddTTL(EMVTagsEnum.MEASURED_RELAY_RESISTANCE_PROCESSING_TIME_DF8306_KRN2, database);
AddTTL(EMVTagsEnum.RRP_COUNTER_DF8307_KRN2, database);
}
public static SignalsEnum Execute(
KernelDatabaseBase database,
KernelQ qManager,
CardQ cardQManager,
Stopwatch sw)
{
if (qManager.GetInputQCount() == 0)
{
throw new EMVProtocolException("Execute_1_Idle: Kernel Input Q empty");
}
KernelRequest kernel2Request = qManager.DequeueFromInput(false);
switch (kernel2Request.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
case KernelTerminalReaderServiceRequestEnum.ACT:
return(EntryPointACT(database, kernel2Request, qManager, cardQManager, sw));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in Execute_1_Idle:" + Enum.GetName(typeof(KernelTerminalReaderServiceRequestEnum), kernel2Request.KernelTerminalReaderServiceRequestEnum));
}
}
private static SignalsEnum EntryPointDET(KernelDatabaseBase database, KernelRequest kernel1Request, CardQ cardQManager, Stopwatch sw)
{
database.UpdateWithDETData(kernel1Request.InputData);
bool missingPDOLData = false;
TLV _9f38 = database.Get(EMVTagsEnum.PROCESSING_OPTIONS_DATA_OBJECT_LIST_PDOL_9F38_KRN);
TLVList pdolList = TLV.DeserializeChildrenWithNoV(_9f38.Value, 0);
DATA_NEEDED_DF8106_KRN2 dataNeeded = new DATA_NEEDED_DF8106_KRN2(database);
foreach (TLV tlv in pdolList)
{
if (database.IsEmpty(tlv.Tag.TagLable))
{
missingPDOLData = true;
dataNeeded.Value.Tags.Add(tlv.Tag.TagLable);
}
}
dataNeeded.UpdateDB();
if (missingPDOLData)
{
return(SignalsEnum.WAITING_FOR_PDOL_DATA);
}
database.Initialize(EMVTagsEnum.PDOL_RELATED_DATA_DF8111_KRN2.Tag);
CommonRoutines.PackRelatedDataTag(database, EMVTagsEnum.PDOL_RELATED_DATA_DF8111_KRN2, pdolList);
EMVGetProcessingOptionsRequest request = new EMVGetProcessingOptionsRequest(database.Get(EMVTagsEnum.PDOL_RELATED_DATA_DF8111_KRN2));
sw.Stop();
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GPO_REPONSE);
}
internal static SignalsEnum PostGenACBalanceReading(KernelDatabaseBase database, KernelQ qManager, CardQ cardQManager)
{
APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2 aci = new APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2(database);
if (!(database.IsNotEmpty(EMVTagsEnum.APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2.Tag) &&
aci.Value.SupportForBalanceReading))
{
return(SignalsEnum.NONE);
}
if (!database.IsPresent(EMVTagsEnum.BALANCE_READ_AFTER_GEN_AC_DF8105_KRN2.Tag))
{
return(SignalsEnum.NONE);
}
EMVGetDataRequest request = new EMVGetDataRequest(Formatting.HexStringToByteArray(EMVTagsEnum.OFFLINE_ACCUMULATOR_BALANCE_9F50_KRN2.Tag));
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
SignalsEnum result = SignalsEnum.WAITING_FOR_POST_GEN_AC_BALANCE;
while (result == SignalsEnum.WAITING_FOR_POST_GEN_AC_BALANCE)
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
result = State_17_WaitingForPostGenACBalance_7_4.Execute_State_17_WaitingForPostGenACBalance(database, qManager, cardQManager);
}
return(result);
}
private static EMVGenerateACRequest DoGAC26(KernelDatabaseBase database)
{
#region GAC.26
REFERENCE_CONTROL_PARAMETER_DF8114_KRN2 rcp = new REFERENCE_CONTROL_PARAMETER_DF8114_KRN2(database);
rcp.Value.ACTypeEnum = GetDSACType(database);
rcp.UpdateDB();
return(DoPart3(database));
#endregion
}
private static EMVGenerateACRequest DoIDSReadOnly(KernelDatabaseBase database)
{
#region GAC.27
REFERENCE_CONTROL_PARAMETER_DF8114_KRN2 rcp = new REFERENCE_CONTROL_PARAMETER_DF8114_KRN2(database);
rcp.Value.ACTypeEnum = GetDSACType(database);
rcp.Value.CDASignatureRequested = true;
rcp.UpdateDB();
return(DoPart3(database));
#endregion
}
public static byte[] OWHF2AES_8_3(KernelDatabaseBase database, byte[] c)
{
byte[] oid = new byte[8];
if (database.IsNotEmpty(EMVTagsEnum.DS_SLOT_MANAGEMENT_CONTROL_9F6F_KRN2.Tag) &&
(database.Get(EMVTagsEnum.DS_SLOT_MANAGEMENT_CONTROL_9F6F_KRN2).Value[0] & 0x80) == 0x80 && // Permanent slot type
(database.Get(EMVTagsEnum.DS_ODS_INFO_DF62_KRN2).Value[0] & 0x40) == 0x40 //Volatile slot type
)
{
oid = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
}
else
{
oid = database.Get(EMVTagsEnum.DS_REQUESTED_OPERATOR_ID_9F5C_KRN2).Value;
}
List <byte[]> keyComps = new List <byte[]>();
keyComps.Add(c);
keyComps.Add(oid);
byte[] m = keyComps.SelectMany(x => x).ToArray();
byte[] dsid = database.Get(EMVTagsEnum.DS_ID_9F5E_KRN2).Value;
byte[] y = new byte[11];
Array.Copy(dsid, 0, y, 0, y.Length);//this will be padded
keyComps = new List <byte[]>();
keyComps.Add(y);
keyComps.Add(new byte[] { oid[5], oid[6], oid[7], oid[8] });
keyComps.Add(new byte[] { 0x3F });
byte[] k = keyComps.SelectMany(x => x).ToArray();
Aes aes = Aes.Create();
aes.Key = k;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.None;
MemoryStream ms = new MemoryStream();
using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(m, 0, m.Length);
}
byte[] t = ms.ToArray();
ms.Dispose();
t = XOR(t, m);
byte[] r = new byte[8];
Array.Copy(t, 0, r, 0, 8);
return(r);
}
private static bool DoDEKIfNeeded(KernelDatabaseBase database, KernelQ qManager)
{
if (database.IsNotEmptyList(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2.Tag) ||
(database.IsNotEmptyList(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2.Tag)))
{
CommonRoutines.PostDEK(database, qManager);
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Initialize();
database.Get(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2).Initialize();
return(true);
}
return(false);
}
public static bool DoDDA(KernelDatabaseBase database, KernelQ qManager, CAPublicKeyCertificate capk, TLV sdadTLV)
{
try
{
TRANSACTION_STATUS_INFORMATION_9B_KRN tsi = new TRANSACTION_STATUS_INFORMATION_9B_KRN(database);
tsi.Value.OfflineDataAuthenticationWasPerformed = true;
tsi.UpdateDB();
if (database.Get(EMVTagsEnum.CERTIFICATION_AUTHORITY_PUBLIC_KEY_INDEX_8F_KRN) == null)
{
return(false);
}
if (capk == null)
{
return(false);
}
TLV aip = database.Get(EMVTagsEnum.APPLICATION_INTERCHANGE_PROFILE_82_KRN.Tag);
int length = database.StaticDataToBeAuthenticated.Serialize().Length;
if (aip != null && database.IsNotEmpty(EMVTagsEnum.STATIC_DATA_AUTHENTICATION_SDA_TAG_LIST_9F4A_KRN3.Tag))
{
if (2048 - length >= aip.Value.Length)
{
database.StaticDataToBeAuthenticated.AddToList(database.Get(EMVTagsEnum.APPLICATION_INTERCHANGE_PROFILE_82_KRN));
}
else
{
return(false);
}
}
if (sdadTLV != null)
{
ICCDynamicData iccdd = VerifySAD.VerifySDAD(ICCDynamicDataType.DYNAMIC_NUMBER_ONLY, database, capk, sdadTLV.Value);
if (iccdd == null)
{
return(false);
}
VerifySAD.AddSDADDataToDatabase(database, iccdd);
return(true);
}
return(false);
}
catch
{
return(false);
}
}
public static SignalsEnum DoInvalidReponse(KernelDatabaseBase database, KernelQ qManager, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true, KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
}
public static SignalsEnum Initiate2ndCardActionAnalysis(KernelDatabaseBase database, KernelQ qManager, CardQ cardQManager, EMVSelectApplicationResponse emvSelectApplicationResponse, bool entryFromScriptProcessingCompleted = false)
{
if (!entryFromScriptProcessingCompleted)
{
//check if scripts need to be run
TLV _71 = database.Get(EMVTagsEnum.ISSUER_SCRIPT_TEMPLATE_1_71_KRN);
if (_71 != null)
{
((KernelDatabase)database).ScriptsToRunBeforeGenAC = BuildScriptList(_71);
if (((KernelDatabase)database).ScriptsToRunBeforeGenAC.Count > 0)
{
((KernelDatabase)database).IsScriptProcessingBeforeGenACInProgress = true;
//post first script
TLV firstScript = ((KernelDatabase)database).ScriptsToRunBeforeGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
}
}
APPLICATION_INTERCHANGE_PROFILE_82_KRN aip = new APPLICATION_INTERCHANGE_PROFILE_82_KRN(database);
TERMINAL_CAPABILITIES_9F33_KRN tc = new TERMINAL_CAPABILITIES_9F33_KRN(database);
//section 6.5.5 in Book 3
TLV cdol2 = database.Get(EMVTagsEnum.CARD_RISK_MANAGEMENT_DATA_OBJECT_LIST_2_CDOL2_8D_KRN);
byte[] cdol2Data = CommonRoutines.PackRelatedDataTag(database, cdol2);
REFERENCE_CONTROL_PARAMETER_DF8114_KRN2 rcpST = new REFERENCE_CONTROL_PARAMETER_DF8114_KRN2(database);
rcpST.Value.ACTypeEnum = GetDSACType(database);
if (aip.Value.CDASupported && tc.Value.CDACapable)
{
rcpST.Value.CDASignatureRequested = true;
}
else
{
rcpST.Value.CDASignatureRequested = false;
}
rcpST.UpdateDB();
EMVGenerateACRequest request = new EMVGenerateACRequest(cdol2Data, null, rcpST);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GEN_AC_2);
}
private static EMVGenerateACRequest DoNoIDS(KernelDatabaseBase database)
{
#region GAC.20
if (GetODAStatus(database) == 0x80)
{
#region GAC.21
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
if (tvr.Value.CDAFailed)
#endregion
{
return(DoGAC22_26(database));
}
else
{
#region GAC.24
if (GetDSACType(database) == ACTypeEnum.AAC)
#endregion
{
APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2 aci = new APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2(database);
#region GAC.25
if (database.IsNotEmpty(EMVTagsEnum.APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2.Tag) &&
aci.Value.CDAIndicatorEnum == CDAIndicatorEnum.CDA_SUPPORTED_OVER_TC_ARQC_AAC)
{
#region GAC.27
return(DoIDSReadOnly(database));
#endregion
}
else
{
return(DoGAC26(database));
}
#endregion
}
else
{
#region GAC.27
return(DoIDSReadOnly(database));
#endregion
}
}
}
else
{
return(DoGAC22_26(database));
}
#endregion
}
private static EMVGenerateACRequest DoGAC22_26(KernelDatabaseBase database)
{
#region GAC.22
APPLICATION_INTERCHANGE_PROFILE_82_KRN aip = new APPLICATION_INTERCHANGE_PROFILE_82_KRN(database);
KERNEL_CONFIGURATION_DF811B_KRN2 kc = new KERNEL_CONFIGURATION_DF811B_KRN2(database);
if (aip.Value.OnDeviceCardholderVerificationIsSupported && kc.Value.OnDeviceCardholderVerificationSupported)
#endregion
{
#region GAC.23
SetDSACType(database, ACTypeEnum.AAC);
#endregion
}
return(DoGAC26(database));
}
public static SignalsEnum DoCommonProcessing(string source, KernelDatabaseBase databaseIn, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager pkcm, CardExceptionManager cardExceptionManager)
{
Kernel1Database database = (Kernel1Database)databaseIn;
if (database.NextCommandEnum == NextCommandEnum.READ_RECORD)
{
DoDEKIfNeeded(database, qManager);
return(SignalsEnum.WAITING_FOR_EMV_READ_RECORD_RESPONSE);
}
DoDEKIfNeeded(database, qManager);
//ReaderContactlessTransactionLimit exceeded
if (database.ProcessingIndicatorsForSelected.ContactlessApplicationNotAllowed)
{
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcomeWithError(database, qManager, Kernel2OutcomeStatusEnum.SELECT_NEXT, Kernel2StartEnum.C, L1Enum.NOT_SET, L2Enum.MAX_LIMIT_EXCEEDED, L3Enum.NOT_SET));
}
bool goOnline = false;
#region 3.2.1.1
if (database.IsPresent(EMVTagsEnum.VLP_ISSUER_AUTHORISATION_CODE_9F74_KRN1.Tag))
{
if (database.ProcessingIndicatorsForSelected.ReaderContactlessFloorLimitExceeded)
{
goOnline = true;
}
if (database.ProcessingIndicatorsForSelected.ReaderCVMRequiredLimitExceeded)
{
goOnline = true;
}
}
else
{
goOnline = true;
}
#endregion
if (goOnline)
{
return(DoOnlineProcess(database, cardQManager));
}
else
{
return(DoOfflineProcess(database, cardQManager));
}
}
private static EMVGenerateACRequest DoPart3(KernelDatabaseBase database)
{
TLV cdol1 = database.Get(EMVTagsEnum.CARD_RISK_MANAGEMENT_DATA_OBJECT_LIST_1_CDOL1_8C_KRN);
CommonRoutines.PackRelatedDataTag(database, EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2, cdol1);
REFERENCE_CONTROL_PARAMETER_DF8114_KRN2 rcpST = new REFERENCE_CONTROL_PARAMETER_DF8114_KRN2(database);
rcpST.Value.ACTypeEnum = GetDSACType(database);
rcpST.Value.CDASignatureRequested = GetODAStatus(database) == 0x80 ? true : false;
rcpST.UpdateDB();
EMVGenerateACRequest request = new EMVGenerateACRequest(database.Get(EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2), null, rcpST);
return(request);
}
private static SignalsEnum DoCommon(KernelDatabaseBase database, KernelQ qManager)
{
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET,
null,
L2Enum.PARSING_ERROR,
L3Enum.NOT_SET));
}
private static SignalsEnum EntryPointL1RSP(KernelDatabaseBase database, CardResponse cardResponse, KernelQ qManager)
{
CommonRoutines.InitializeDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.TRY_AGAIN,
KernelStatusEnum.READY_TO_READ,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.B,
false,
KernelMessageidentifierEnum.TRY_AGAIN,
L1Enum.NOT_SET,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
private static EMVGenerateACRequest DoIDSWrite(KernelDatabaseBase database)
{
#region GAC.40
TLVList tags = TLV.DeserializeChildrenWithNoV(database.Get(EMVTagsEnum.DSDOL_9F5B_KRN2).Value, 0);
if (tags.Get(EMVTagsEnum.DS_DIGEST_H_DF61_KRN2.Tag) != null)
#endregion
{
#region GAC.41
if (database.IsPresent(EMVTagsEnum.DS_INPUT_TERM_DF8109_KRN2.Tag))
#endregion
{
#region GAC.42
APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2 aci = new APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2(database);
TLV dsit = database.Get(EMVTagsEnum.DS_INPUT_TERM_DF8109_KRN2);
TLV dsdh = database.Get(EMVTagsEnum.DS_DIGEST_H_DF61_KRN2.Tag);
if (aci.Value.DataStorageVersionNumberEnum == DataStorageVersionNumberEnum.VERSION_1)
#endregion
{
#region GAC.43
dsdh.Value = OWHF2.OWHF2_8_2(database, dsit.Value);
#endregion
}
else
{
#region GAC.44
dsdh.Value = OWHF2.OWHF2AES_8_3(database, dsit.Value);
#endregion
}
return(DoPart4(database));
}
else
{
#region GAC.45
return(DoPart4(database));
#endregion
}
}
else
{
#region GAC.45
return(DoPart4(database));
#endregion
}
}
public static SignalsEnum DoOnlineProcess(KernelDatabaseBase database, CardQ cardQManager)
{
#region 3.5.1.1
TLV tvr = database.Get(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN);
if (tvr == null)
{
tvr = TLV.Create(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN.Tag, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00 });
database.AddToList(tvr);
}
TLV cdol1 = database.Get(EMVTagsEnum.CARD_RISK_MANAGEMENT_DATA_OBJECT_LIST_1_CDOL1_8C_KRN);
byte[] cdol1RelatedData = CommonRoutines.PackRelatedDataTag(database, cdol1);
EMVGenerateACRequest request = new EMVGenerateACRequest(cdol1RelatedData);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GEN_AC_1);
#endregion
}
/*
* S17.2
*/
private static SignalsEnum EntryPointRA(KernelDatabaseBase database, CardResponse cardResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(SignalsEnum.NONE);
}
if (cardResponse.ApduResponse.ResponseData.Length == 9 &&
cardResponse.ApduResponse.ResponseData[0] == 0x9F &&
cardResponse.ApduResponse.ResponseData[1] == 0x50 &&
cardResponse.ApduResponse.ResponseData[2] == 0x06)
{
byte[] bal = new byte[5];
Array.Copy(cardResponse.ApduResponse.ResponseData, 3, bal, 0, bal.Length);
database.Get(EMVTagsEnum.BALANCE_READ_AFTER_GEN_AC_DF8105_KRN2).Value = bal;
}
return(SignalsEnum.NONE);
}
private static EMVGenerateACRequest GenerateErrorOutput(KernelDatabaseBase database, L2Enum l2ErrorEnum, KernelQ qManager)
{
#region GAC.12, GAC.13
CommonRoutines.CreateEMVDiscretionaryData(database);
CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET,
null,
l2ErrorEnum,
L3Enum.NOT_SET);
return(null);
#endregion
}
public static SignalsEnum DoOfflineProcess(KernelDatabaseBase database, CardQ cardQManager)
{
#region 3.4.1.1 and 3.4.1.2
TLV ddol = database.Get(EMVTagsEnum.DYNAMIC_DATA_AUTHENTICATION_DATA_OBJECT_LIST_DDOL_9F49_KRN);
byte[] ddolRelatedData;
if (ddol == null)
{
TLV unpred = database.Get(EMVTagsEnum.UNPREDICTABLE_NUMBER_9F37_KRN);
unpred.Val.PackValue(unpred.Val.GetLength());
ddolRelatedData = unpred.Value;
}
else
{
ddolRelatedData = CommonRoutines.PackRelatedDataTag(database, ddol);
}
EMVInternalAuthenticateRequest request = new EMVInternalAuthenticateRequest(ddolRelatedData);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_INTERNAL_AUTHENTICATE);
#endregion
}
public static SignalsEnum Execute(
KernelDatabaseBase database,
KernelQ qManager,
CardQ cardQManager,
Stopwatch sw,
PublicKeyCertificateManager publicKeyCertificateManager,
CardExceptionManager cardExceptionManager,
Func <string, KernelDatabaseBase, KernelQ, CardQ, Stopwatch, PublicKeyCertificateManager, CardExceptionManager, SignalsEnum> ReadRecordCompleteCallback)
{
if (qManager.GetOutputQCount() > 0) //there is a pending request to the terminal
{
KernelRequest kernel1Request = qManager.DequeueFromInput(false);
switch (kernel1Request.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
case KernelTerminalReaderServiceRequestEnum.DET:
return(EntryPointDET(database, kernel1Request));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
else
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
switch (cardResponse.CardInterfaceServiceResponseEnum)
{
case CardInterfaceServiceResponseEnum.RA:
return(EntryPointRA(database, cardResponse, qManager, cardQManager, sw, publicKeyCertificateManager, cardExceptionManager, ReadRecordCompleteCallback));
case CardInterfaceServiceResponseEnum.L1RSP:
return(EntryPointL1RSP(database, cardResponse, qManager));
default:
throw new EMVProtocolException("Invalid Kernel1CardinterfaceServiceResponseEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
public static SignalsEnum DoCommonProcessing(string source, KernelDatabaseBase database, KernelQ qManager, CardQ cardQManager, CardResponse cardResponse)
{
if (database.ActiveAFL == null)
{
return(DoInvalidReponse(database, qManager, L1Enum.NOT_SET, L2Enum.CARD_DATA_ERROR, L3Enum.NOT_SET));
}
else
{
EMVReadRecordRequest request = new EMVReadRecordRequest(database.ActiveAFL.Value.Entries[0].SFI, database.ActiveAFL.Value.Entries[0].FirstRecordNumber);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
database.NextCommandEnum = NextCommandEnum.READ_RECORD;
}
if (database.IsNotEmptyList(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2.Tag) ||
(database.IsNotEmptyList(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2.Tag) && database.TagsToReadYet.Count == 0))
{
CommonRoutines.PostDEK(database, qManager);
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Initialize();
database.Get(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2).Initialize();
}
return(SignalsEnum.WAITING_FOR_EMV_READ_RECORD_RESPONSE);
}
public static SignalsEnum Execute(
KernelDatabaseBase database,
KernelQ qManager,
CardQ cardQManager,
Stopwatch sw)
{
KernelRequest kernel1Request = qManager.DequeueFromInput(false);
switch (kernel1Request.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
case KernelTerminalReaderServiceRequestEnum.TIMEOUT:
return(EntryPointTIMEOUT(database, qManager));
case KernelTerminalReaderServiceRequestEnum.DET:
return(EntryPointDET(database, kernel1Request, cardQManager, sw));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in Execute_1_Idle:" + Enum.GetName(typeof(KernelTerminalReaderServiceRequestEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
private static void Do434(KernelDatabaseBase database, bool signedFlag, int sfi, CardResponse cardResponse, TLVList responseTags)
{
if (signedFlag)
{
if (sfi <= 10)
{
int length = cardResponse.ApduResponse.ResponseData.Length - 2; //without tag '70' and length
if (2048 - database.StaticDataToBeAuthenticated.Serialize().Length >= length)
{
database.StaticDataToBeAuthenticated.AddListToList(responseTags);
}
else
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.CDAFailed = true;
tvr.UpdateDB();
}
}
else
{
int length = cardResponse.ApduResponse.ResponseData.Length;
if (cardResponse.ApduResponse.ResponseData[0] == 0x70 && 2048 - database.StaticDataToBeAuthenticated.Serialize().Length >= length)
{
TLV template = TLV.Create(EMVTagsEnum.READ_RECORD_RESPONSE_MESSAGE_TEMPLATE_70_KRN.Tag);
template.Children.AddListToList(responseTags);
template.Serialize();
database.StaticDataToBeAuthenticated.AddToList(template);
}
else
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.CDAFailed = true;
tvr.UpdateDB();
}
}
}
}
public static byte[] BuildPinVerifyData(KernelDatabaseBase database, CAPublicKeyCertificate caPublicKey, byte[] pinBlock, byte[] challenge)
{
IssuerPublicKeyCertificate ipk = IssuerPublicKeyCertificate.BuildAndValidatePublicKey(database, caPublicKey.Modulus, caPublicKey.Exponent);
if (ipk == null)
{
return(null);
}
int keyLength = 0;
PublicKeyCertificate iccKey = IccPinKeyCertificate.BuildAndValidatePublicKey(database, ipk.Modulus, ipk.Exponent);
if (iccKey == null)
{
iccKey = IccPublicKeyCertificate.BuildAndValidatePublicKey(database, database.StaticDataToBeAuthenticated, ipk.Modulus, ipk.Exponent);
if (iccKey == null)
{
return(null);
}
keyLength = ((IccPublicKeyCertificate)iccKey).ICCPublicKeyLength;
}
else
{
keyLength = ((IccPinKeyCertificate)iccKey).ICCPinKeyLength;
}
int paddingLength = keyLength - 17;
byte[] padding = new byte[paddingLength];
byte[] pinData = Formatting.ConcatArrays(new byte[] { 0x7F }, pinBlock, challenge, padding);
//apply recovery function
byte[] encryptedPin = PublicKeyCertificate.DecryptRSA(pinData, iccKey.Modulus, iccKey.Exponent);
return(encryptedPin);
}
