internal static SignalsEnum PreGenACBalanceReading(Kernel2Database 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_PRE_GEN_AC_BALANCE;
while (result == SignalsEnum.WAITING_FOR_PRE_GEN_AC_BALANCE)
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
result = State_16_WaitingForPreGenACBalance_7_2.Execute_State_16_WaitingForPreGenACBalance(database, qManager, cardQManager);
}
return(result);
}
private static SignalsEnum Do78_3(string source, Kernel2Database database, KernelQ qManager, Stopwatch sw)
{
#region 78.3
foreach (TLV tlv in database.TagsToReadYet)
{
if (database.IsNotEmpty(tlv.Tag.TagLable))
{
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Children.AddToList(tlv);
database.TagsToReadYet.RemoveFromList(tlv);
}
}
#endregion
#region 78.4
if (database.IsNotEmptyList(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2.Tag) ||
database.IsNotEmptyList(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2.Tag) &&
database.TagsToReadYet.Count == 0
)
#endregion
{
#region 78.5
CommonRoutines.PostDEK(database, qManager);
database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Initialize();
database.Get(EMVTagsEnum.DATA_NEEDED_DF8106_KRN2).Initialize();
#endregion
}
#region 78.6
sw.Start();
#endregion
return(SignalsEnum.WAITING_FOR_MAG_STRIPE_FIRST_WRITE_FLAG);
}
private static bool VerifySDAD_Summaries_42(Kernel2Database database, CAPublicKeyCertificate capk, CardResponse cardResponse)
{
ICCDynamicData iccdd = VerifySAD.VerifySDAD(ICCDynamicDataType.IDS, true, database, database.StaticDataToBeAuthenticated, capk, cardResponse);
if (iccdd == null)
{
return(false);
}
AddSDADDataToDatabase(database, iccdd);
TLV ds2 = database.Get(EMVTagsEnum.DS_SUMMARY_2_DF8101_KRN2);
TLV ds3 = database.Get(EMVTagsEnum.DS_SUMMARY_3_DF8102_KRN2);
if (ds2 == null && iccdd.DSSummary2 != null)
{
ds2 = TLV.Create(EMVTagsEnum.DS_SUMMARY_2_DF8101_KRN2.Tag);
}
if (ds3 == null && iccdd.DSSummary3 != null)
{
ds3 = TLV.Create(EMVTagsEnum.DS_SUMMARY_3_DF8102_KRN2.Tag);
}
if (iccdd.DSSummary2 != null)
{
ds2.Value = iccdd.DSSummary2;
}
if (iccdd.DSSummary3 != null)
{
ds3.Value = iccdd.DSSummary3;
}
return(true);
}
public static SignalsEnum Execute(
Kernel2Database 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_4_TerminateOnNextRA:" + 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_4_TerminateOnNextRA:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
/*
* 15.2
*/
private static SignalsEnum EntryPointRA(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, TornTransactionLogManager tornTransactionLogManager, Stopwatch sw)
{
#region 15.5
if (cardResponse.ApduResponse.Succeeded)
#endregion
{
#region 15.6
if (database.TagsToWriteAfterGenACYet.Count != 0)
#endregion
{
#region 15.7
TLV tagToPut = database.TagsToWriteAfterGenACYet.GetFirstAndRemoveFromList();
EMVPutDataRequest requestPutData = new EMVPutDataRequest(tagToPut);
#endregion
#region 15.8
cardQManager.EnqueueToInput(new CardRequest(requestPutData, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_PUT_DATA_RESPONSE_AFTER_GEN_AC);
#endregion
}
else
{
#region 15.9
byte pgacps = database.Get(EMVTagsEnum.POSTGEN_AC_PUT_DATA_STATUS_DF810E_KRN2).Value[0];
pgacps = (byte)(pgacps | 0x80);
database.Get(EMVTagsEnum.POSTGEN_AC_PUT_DATA_STATUS_DF810E_KRN2).Value[0] = pgacps;
#endregion
}
}
return(DoCommon(database, cardResponse, qManager));
}
/*
* SR1.6 - SR1.8
*/
private static SignalsEnum EntryPointSTOP(Kernel2Database database, KernelQ qManager, Stopwatch sw)
{
sw.Stop();
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcomeWithError(database, qManager, Kernel2OutcomeStatusEnum.END_APPLICATION, Kernel2StartEnum.N_A, L1Enum.NOT_SET, L2Enum.NOT_SET, L3Enum.STOP));
}
/*
* S6.5 - S6.7
*/
private static SignalsEnum EntryPointDET(Kernel2Database database, KernelRequest kernel1Request, KernelQ qManager, CardQ cardQManager, TornTransactionLogManager tornTransactionLogManager, Stopwatch sw)
{
#region 6.6
database.UpdateWithDETData(kernel1Request.InputData);
#endregion
#region 6.7
sw.Stop();
#endregion
#region 6.8
TLV nextTLV = database.TagsToReadYet.GetNextGetDataTagFromList();
if (nextTLV != null)
database.ActiveTag = nextTLV.Tag.TagLable;
else
database.ActiveTag = null;
if (database.ActiveTag != null)
#endregion
{
#region 6.9 - 6.12
EMVGetDataRequest request = new EMVGetDataRequest(Formatting.HexStringToByteArray(database.ActiveTag));
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
database.NextCommandEnum = NextCommandEnum.GET_DATA;
#endregion
}
else
{
#region 6.12
database.NextCommandEnum = NextCommandEnum.NONE;
#endregion
}
return State_4_5_6_CommonProcessing.DoCommonProcessing("State_6_WaitingForEMVModeFirstWriteFlag", database, qManager, cardQManager, sw, tornTransactionLogManager);
}
public static SignalsEnum DoInvalidResponsePart_C(Kernel2Database database, KernelQ qManager, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
#region 9_10.50
CommonRoutines.UpdateUserInterfaceRequestData(database, KernelMessageidentifierEnum.ERROR_OTHER_CARD, KernelStatusEnum.NOT_READY);
#endregion
#region 9_10.51
IDS_STATUS_DF8128_KRN2 ids = new IDS_STATUS_DF8128_KRN2(database);
CommonRoutines.CreateEMVDiscretionaryData(database);
if (ids.Value.IsWrite)
#endregion
{
#region 9_10.52
CommonRoutines.CreateEMVDataRecord(database);
#endregion
}
#region 9_10.53
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.N_A,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
l1Enum,
null,
l2Enum,
l3Enum));
#endregion
}
/*
* 14.1
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, TornTransactionLogManager tornTransactionLogManager)
{
#region 14.2
int waitTime = ((2 ^ database.FailedMSCntr) * 300);
Task.Delay(TimeSpan.FromMilliseconds(waitTime)).Wait();
#endregion
#region 14.3
database.FailedMSCntr = Math.Min(database.FailedMSCntr + 1, 5);
#endregion
#region 14.4 - 14.5
CommonRoutines.CreateEMVDiscretionaryData(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));
#endregion
}
/*
* S1.4, S1.5 and S1.6
*/
private static SignalsEnum EntryPointCLEAN(Kernel2Database database, KernelRequest kernel1Request, KernelQ qManager, TornTransactionLogManager tornTransactionLogManager)
{
foreach (TLV tlv in kernel1Request.InputData)
{
bool updateConditionsOfTIncludeACTSignal = EMVTagsEnum.DoesTagIncludesPermission(tlv.Tag.TagLable, UpdatePermissionEnum.ACT);
if ((database.IsKnown(tlv.Tag.TagLable) || database.IsPresent(tlv.Tag.TagLable)) && updateConditionsOfTIncludeACTSignal)
{
database.AddToList(tlv);
}
}
TLV discretionaryData = CommonRoutines.InitializeDiscretionaryData(database);
foreach (TORN_RECORD_FF8101_KRN2 ttl in tornTransactionLogManager.TornTransactionLogs)
{
DateTime ttlTransactionDate = EMVTagsEnum.TRANSACTION_DATE_9A_KRN.FormatAsDateTime(ttl.Children.Get(EMVTagsEnum.TRANSACTION_DATE_9A_KRN.Tag).Value);
DateTime ttlTransactionTime = EMVTagsEnum.TRANSACTION_TIME_9F21_KRN.FormatAsDateTime(ttl.Children.Get(EMVTagsEnum.TRANSACTION_TIME_9F21_KRN.Tag).Value);
DateTime configTransactionDate = EMVTagsEnum.TRANSACTION_DATE_9A_KRN.FormatAsDateTime(database.Get(EMVTagsEnum.TRANSACTION_DATE_9A_KRN.Tag).Value);
DateTime configTransactionTime = EMVTagsEnum.TRANSACTION_TIME_9F21_KRN.FormatAsDateTime(database.Get(EMVTagsEnum.TRANSACTION_TIME_9F21_KRN.Tag).Value);
TimeSpan tsDate = ttlTransactionDate - configTransactionDate;
TimeSpan tsTime = ttlTransactionTime - configTransactionTime;
int totalSeconds = tsDate.Seconds + tsTime.Seconds;
int defaultToCheck = (int)Formatting.ConvertToInt32(database.GetDefault(EMVTagsEnum.MAX_LIFETIME_OF_TORN_TRANSACTION_LOG_RECORD_DF811C_KRN2).Value);
if (totalSeconds > defaultToCheck)
{
discretionaryData.Children.AddToList(ttl);
tornTransactionLogManager.TornTransactionLogs.RemoveFromList(ttl);
}
}
return(CommonRoutines.PostOutcomeOnly(database, qManager, Kernel2OutcomeStatusEnum.END_APPLICATION, Kernel2StartEnum.N_A));
}
public static SignalsEnum Execute(
Kernel2Database database,
KernelQ qManager,
CardQ cardQManager,
TornTransactionLogManager tornTransactionLogManager,
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.CLEAN:
return(EntryPointCLEAN(database, kernel2Request, qManager, tornTransactionLogManager));
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));
}
}
public Kernel2(TransactionTypeEnum tt, TornTransactionLogManager tornTransactionLogManager, CardQProcessor cardQProcessor, PublicKeyCertificateManager publicKeyCertificateManager, EntryPointPreProcessingIndicators processingIndicatorsForSelected, CardExceptionManager cardExceptionManager, IConfigurationProvider configProvider)
: base(cardQProcessor, publicKeyCertificateManager, processingIndicatorsForSelected, cardExceptionManager, configProvider)
{
this.tornTransactionLogManager = tornTransactionLogManager;
database = new Kernel2Database(publicKeyCertificateManager);
database.InitializeDefaultDataObjects(tt, configProvider);
}
private static SignalsEnum DoCommon(Kernel2Database database, CardResponse cardResponse, KernelQ qManager)
{
#region 15.9.1
if (database.IsNotEmpty(EMVTagsEnum.POS_CARDHOLDER_INTERACTION_INFORMATION_DF4B_KRN2.Tag) &&
((int)Formatting.ConvertToInt32(database.Get(EMVTagsEnum.POS_CARDHOLDER_INTERACTION_INFORMATION_DF4B_KRN2).Value) & 0x00030F) != 0x000000)
#endregion
{
#region 15.10
CommonRoutines.PostUIOnly(database, qManager, KernelMessageidentifierEnum.CLEAR_DISPLAY, KernelStatusEnum.CARD_READ_SUCCESSFULLY, true);
#endregion
//TODO: this changes ui in db which means when response is dequeued, it will have been
//changed by code below, should we not create a copy in Kernel2Response constructor
#region 15.11
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.READY_TO_READ,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
false,
KernelMessageidentifierEnum.N_A,
L1Enum.NOT_SET,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
#endregion
}
else
{
#region 15.12
CommonRoutines.PostUIOnly(database, qManager, KernelMessageidentifierEnum.CLEAR_DISPLAY, KernelStatusEnum.CARD_READ_SUCCESSFULLY, false);
//TODO: we created a temp ui and never saved it to db, so what ui is used below
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.N_A,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.N_A,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.N_A,
L1Enum.NOT_SET,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
#endregion
}
}
private static bool VerifySDAD_9_10__4(Kernel2Database database, CAPublicKeyCertificate capk, CardResponse cardResponse)
{
ICCDynamicData iccdd = VerifySAD.VerifySDAD(ICCDynamicDataType.NO_IDS_OR_RRP, true, database, database.StaticDataToBeAuthenticated, capk, cardResponse);
if (iccdd == null)
{
return(false);
}
VerifySAD.AddSDADDataToDatabase(database, iccdd);
return(true);
}
private static SignalsEnum DoPart_F(Kernel2Database database, KernelQ qManager, CardResponse cardResponse)
{
#region 9_10.46
//see below
#endregion
#region 9_10.46.1
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.CDAFailed = true;
tvr.UpdateDB();
#endregion
return(DoInvalidResponsePart_C(database, qManager, L1Enum.NOT_SET, L2Enum.CAM_FAILED, L3Enum.NOT_SET));
}
/*
* S4.4 - S4.6
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database 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));
}
/*
* 7.4, 7.5, 7.6
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, TornTransactionLogManager tornTransactionLogManager)
{
CommonRoutines.CreateMSDiscretionaryDataRecord(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,
cardResponse.L1Enum,
null,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
public static SignalsEnum DoInvalidReponse(Kernel2Database database, KernelQ qManager, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
#region 3.90.1, 3.90.2
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,
null,
l2Enum,
l3Enum));
#endregion
}
private static SignalsEnum DoInvalidResponsePart_C(Kernel2Database database, KernelQ qManager, CardResponse cardResponse, KernelMessageidentifierEnum message, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
#region 11.90
//done in 11.95
#endregion
#region 11.91
IDS_STATUS_DF8128_KRN2.IDS_STATUS_DF8128_KRN2_VALUE idsV = new IDS_STATUS_DF8128_KRN2.IDS_STATUS_DF8128_KRN2_VALUE(EMVTagsEnum.IDS_STATUS_DF8128_KRN2.DataFormatter);
idsV.Deserialize(database.TornTempRecord.Children.Get(EMVTagsEnum.IDS_STATUS_DF8128_KRN2.Tag).Value, 0);
if (!idsV.IsWrite)
#endregion
{
#region 11.92
database.Get(EMVTagsEnum.TORN_RECORD_FF8101_KRN2).Value = database.TornTempRecord.Value;
#endregion
}
#region 11.93
IDS_STATUS_DF8128_KRN2 ids = new IDS_STATUS_DF8128_KRN2(database);
CommonRoutines.CreateEMVDiscretionaryData(database);
if (ids.Value.IsWrite)
#endregion
{
#region 11.94
CommonRoutines.CreateEMVDataRecord(database);
#endregion
}
#region 11.95
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
message,
l1Enum,
cardResponse.ApduResponse.SW12,
l2Enum,
l3Enum));
#endregion
}
/*
* SR1.3 - SR1.5
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, Stopwatch sw)
{
sw.Stop();
CommonRoutines.CreateEMVDiscretionaryData(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,
null,
L2Enum.CARD_DATA_ERROR,
L3Enum.NOT_SET));
}
private static SignalsEnum DoCommon(Kernel2Database database, KernelQ qManager)
{
#region 4.1, 4.2
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));
#endregion
}
private static SignalsEnum DoInvalidResponsePart_D(Kernel2Database database, KernelQ qManager, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
#region 9_10.61 and 9_10.62
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
database.GetDefault(EMVTagsEnum.MESSAGE_HOLD_TIME_DF812D_KRN2).Value,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
l1Enum,
null,
l2Enum,
l3Enum));
#endregion
}
/*
* S16.4
*/
private static SignalsEnum EntryPointRA(Kernel2Database 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_BEFORE_GEN_AC_DF8104_KRN2).Value = bal;
}
return(SignalsEnum.NONE);
}
private static SignalsEnum DoInvalidResponse(Kernel2Database database, KernelQ qManager)
{
#region 7.24.1
CommonRoutines.CreateMSDiscretionaryDataRecord(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.CARD_DATA_ERROR,
L3Enum.NOT_SET));
#endregion
}
/*
* S2.5 - S2.??
*/
private static SignalsEnum EntryPointDET(Kernel2Database database, KernelRequest kernel1Request, CardQ cardQManager, Stopwatch sw)
{
#region S2.6
database.UpdateWithDETData(kernel1Request.InputData);
#endregion
#region S2.7
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);
}
#endregion
#region S2.8
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));
#endregion
#region S2.9
sw.Stop();
#endregion
#region S2.10
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
#endregion
return(SignalsEnum.WAITING_FOR_GPO_REPONSE);
}
private static void Do434(Kernel2Database database, bool signedFlag, int sfi, CardResponse cardResponse, TLVList responseTags)
{
#region 4.34
if (signedFlag && database.ODAStatus == 0x80)
{
#region 4.35
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();
}
}
#endregion
}
#endregion
}
/*
* 11.1
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, TornTransactionLogManager tornTransactionLogManager)
{
#region 11.11
IDS_STATUS_DF8128_KRN2.IDS_STATUS_DF8128_KRN2_VALUE idsV = new IDS_STATUS_DF8128_KRN2.IDS_STATUS_DF8128_KRN2_VALUE(EMVTagsEnum.IDS_STATUS_DF8128_KRN2.DataFormatter);
idsV.Deserialize(database.TornTempRecord.Children.Get(EMVTagsEnum.IDS_STATUS_DF8128_KRN2.Tag).Value, 0);
if (!idsV.IsWrite)
#endregion
{
#region 11.12
tornTransactionLogManager.TornTransactionLogs.RemoveFromList(database.Get(EMVTagsEnum.TORN_RECORD_FF8101_KRN2));
#endregion
}
#region 11.13
database.TornTempRecord = new TORN_RECORD_FF8101_KRN2(database);
database.TornTempRecord.Initialize();
database.TornTempRecord.AddTornTransactionLog(database);
#endregion
#region 11.15
tornTransactionLogManager.AddTornTransactionLog(database);
#endregion
#region 11.16 - 11.17
CommonRoutines.CreateEMVDiscretionaryData(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));
#endregion
}
private static void AddSDADDataToDatabase(Kernel2Database database, ICCDynamicData iccdd)
{
TLV iccdn = database.Get(EMVTagsEnum.ICC_DYNAMIC_NUMBER_9F4C_KRN);
TLV ac = database.Get(EMVTagsEnum.APPLICATION_CRYPTOGRAM_9F26_KRN);
if (iccdn == null)
{
iccdn = TLV.Create(EMVTagsEnum.ICC_DYNAMIC_NUMBER_9F4C_KRN.Tag);
}
if (ac == null)
{
ac = TLV.Create(EMVTagsEnum.APPLICATION_CRYPTOGRAM_9F26_KRN.Tag);
}
iccdn.Value = iccdd.ICCDynamicNumber;
ac.Value = iccdd.ApplicationCryptogram;
database.AddToList(iccdn);
database.AddToList(ac);
}
private static bool VerifySDAD_CheckRelayData_9_10__4_1(Kernel2Database database, CAPublicKeyCertificate capk, CardResponse cardResponse)
{
ICCDynamicData iccdd = VerifySAD.VerifySDAD(ICCDynamicDataType.RRP, true, database, database.StaticDataToBeAuthenticated, capk, cardResponse);
if (iccdd == null)
{
return(false);
}
VerifySAD.AddSDADDataToDatabase(database, iccdd);
string s1 = Formatting.ByteArrayToHexString(database.Get(EMVTagsEnum.TERMINAL_RELAY_RESISTANCE_ENTROPY_DF8301_KRN2).Value);
string s2 = Formatting.ByteArrayToHexString(database.Get(EMVTagsEnum.DEVICE_RELAY_RESISTANCE_ENTROPY_DF8302_KRN2).Value);
string s3 = Formatting.ByteArrayToHexString(database.Get(EMVTagsEnum.MIN_TIME_FOR_PROCESSING_RELAY_RESISTANCE_APDU_DF8303_KRN2).Value);
string s4 = Formatting.ByteArrayToHexString(database.Get(EMVTagsEnum.MAX_TIME_FOR_PROCESSING_RELAY_RESISTANCE_APDU_DF8304_KRN2).Value);
string s5 = Formatting.ByteArrayToHexString(database.Get(EMVTagsEnum.DEVICE_ESTIMATED_TRANSMISSION_TIME_FOR_RELAY_RESISTANCE_RAPDU_DF8305_KRN2).Value);
if (s1 != Formatting.ByteArrayToHexString(iccdd.Terminal_Relay_Resistance_Entropy))
{
return(false);
}
if (s2 != Formatting.ByteArrayToHexString(iccdd.Device_Relay_Resistance_Entropy))
{
return(false);
}
if (s3 != Formatting.ByteArrayToHexString(iccdd.Min_Time_For_Processing_Relay_Resistance_APDU))
{
return(false);
}
if (s4 != Formatting.ByteArrayToHexString(iccdd.Max_Time_For_Processing_Relay_Resistance_APDU))
{
return(false);
}
if (s5 != Formatting.ByteArrayToHexString(iccdd.Device_Estimated_Transmission_Time_For_Relay_Resistance_R_APDU))
{
return(false);
}
return(true);
}
public static SignalsEnum Execute(
Kernel2Database database,
KernelQ qManager,
CardQ cardQManager,
TornTransactionLogManager tornTransactionLogManager,
PublicKeyCertificateManager publicKeyCertificateManager,
Stopwatch sw)
{
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_14_WaitingForCCCResponse2:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
else
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
switch (cardResponse.CardInterfaceServiceResponseEnum)
{
case CardInterfaceServiceResponseEnum.RA:
return(EntryPointRA(database, cardResponse, qManager, cardQManager, tornTransactionLogManager, sw, publicKeyCertificateManager));
case CardInterfaceServiceResponseEnum.L1RSP:
return(EntryPointL1RSP(database, cardResponse, qManager, tornTransactionLogManager));
default:
throw new EMVProtocolException("Invalid Kernel1CardinterfaceServiceResponseEnum in State_14_WaitingForCCCResponse2:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
