private static SignalsEnum EntryPointPIN(KernelDatabase database, KernelRequest kernel1Request, CardQ cardQManager)
{
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
//store the pin
database.AddToList(kernel1Request.InputData.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag));
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
//online pin
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerifiedOnline)
{
PinProcessing.VerifyOnlinePin(pin, tvr, cvr);
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//offline pin
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICCAndSignature_Paper ||
cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICCAndSignature_Paper)
{
EMVGetDataRequest request = new EMVGetDataRequest(Formatting.HexStringToByteArray(EMVTagsEnum.PERSONAL_IDENTIFICATION_NUMBER_PIN_TRY_COUNTER_9F17_KRN.Tag));
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GET_PIN_TRY_COUNTER);
}
throw new EMVProtocolException("Invalid cvr in State_5a_WaitingForGetPinReponse");
}
private static SignalsEnum EntryPointDET(KernelDatabase 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);
}
public static SignalsEnum Execute(
KernelDatabase database,
KernelQ qManager,
CardQ cardQManager,
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_5_WaitingForCVMProcessing:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
else
{
return(ProcessNextCVM(database, qManager, cardQManager, sw));
}
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(State_7_10_CommonProcessing.DoInvalidResponsePart_C(database, qManager, L1Enum.NOT_SET, L2Enum.STATUS_BYTES, L3Enum.NOT_SET));
}
SignalsEnum result = ProcessGenACCommand(database, cardResponse, qManager, cardQManager, sw, publicKeyCertificateManager, emvSelectApplicationResponse);
TLV _72 = database.Get(EMVTagsEnum.ISSUER_SCRIPT_TEMPLATE_2_72_KRN);
if (_72 != null)
{
database.ScriptsToRunAfterGenAC = CardActionAnalysis.BuildScriptList(_72);
if (database.ScriptsToRunAfterGenAC.Count > 0)
{
//post first script
TLV firstScript = database.ScriptsToRunAfterGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
}
return(result);
}
private static SignalsEnum DoEMVMode(KernelDatabase database, KernelQ qManager, CardQ cardQManager, CardResponse cardResponse, Stopwatch sw)
{
TLV aflRaw = database.Get(EMVTagsEnum.APPLICATION_FILE_LOCATOR_AFL_94_KRN);
byte[] kcValCheck = new byte[4];
Array.Copy(aflRaw.Value, 0, kcValCheck, 0, kcValCheck.Length);
//if (aflRaw.Value.Length >= 4 && Formatting.ByteArrayToHexString(kcValCheck) == "08010100")
//{
// byte[] activeAFLBytes = new byte[aflRaw.Value.Length - 4];
// Array.Copy(aflRaw.Value, 4, activeAFLBytes, 0, activeAFLBytes.Length);
// List<byte[]> bytes = new List<byte[]>
// {
// new byte[] { (byte)activeAFLBytes.Length },
// activeAFLBytes
// };
// database.ActiveAFL.Value.Deserialize(bytes.SelectMany(a => a).ToArray(), 0);
//}
//else
//{
List <byte[]> bytes = new List <byte[]>
{
new byte[] { (byte)aflRaw.Value.Length },
aflRaw.Value
};
database.ActiveAFL.Value.Deserialize(bytes.SelectMany(a => a).ToArray(), 0);
//}
return(DoCommonProcessing("State_3_WaitingForGPOResponse", database, qManager, cardQManager, cardResponse));
}
public static SignalsEnum Execute(
KernelDatabase database,
KernelQ qManager,
CardQ cardQManager,
Stopwatch sw)
{
if (qManager.GetInputQCount() == 0)
{
throw new EMVProtocolException("Execute_1_Idle: Kernel Input Q empty");
}
KernelRequest kernelRequest = qManager.DequeueFromInput(false);
switch (kernelRequest.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
case KernelTerminalReaderServiceRequestEnum.ACT:
return(EntryPointACT(database, kernelRequest, qManager, cardQManager, sw));
default:
throw new EMVProtocolException("Invalid KernelTerminalReaderServiceRequestEnum in Execute_1_Idle:" + Enum.GetName(typeof(KernelTerminalReaderServiceRequestEnum), kernelRequest.KernelTerminalReaderServiceRequestEnum));
}
}
public Kernel(TransactionTypeEnum tt, CardQProcessor cardQProcessor, PublicKeyCertificateManager publicKeyCertificateManager, EntryPointPreProcessingIndicators processingIndicatorsForSelected, CardExceptionManager cardExceptionManager, IConfigurationProvider configProvider, EMVSelectApplicationResponse emvSelectApplicationResponse)
: base(cardQProcessor, publicKeyCertificateManager, processingIndicatorsForSelected, cardExceptionManager, configProvider)
{
database = new KernelDatabase(publicKeyCertificateManager);
database.InitializeDefaultDataObjects(tt, configProvider);
this.emvSelectApplicationResponse = emvSelectApplicationResponse;
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw)
{
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
EMVGetDataResponse response = (EMVGetDataResponse)cardResponse.ApduResponse;
if (!response.Succeeded)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//store the pin try counter value
database.AddToList(response.GetResponseTag());
int pinTryCounter = Formatting.ConvertToInt16(database.Get(EMVTagsEnum.PERSONAL_IDENTIFICATION_NUMBER_PIN_TRY_COUNTER_9F17_KRN).Value);
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICCAndSignature_Paper)
{
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
if (!PinProcessing.VerifyOfflinePin(pin, pinTryCounter, tvr, cvr))
{
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//fire off get challenge command
EMVGetChallengeRequest request = new EMVGetChallengeRequest();
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GET_CHALLENGE);
}
if (cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICCAndSignature_Paper)
{
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
if (!PinProcessing.VerifyOfflinePin(pin, pinTryCounter, tvr, cvr))
{
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
byte[] pinData = PinProcessing.BuildPlainTextPinBlock(pin);
//fire off verify for plain text pin
EMVVerifyRequest request = new EMVVerifyRequest(VerifyCommandDataQualifier.Plaintext_PIN, pinData);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_VERIFY);
}
throw new EMVProtocolException("Invalid cvr in State_5b_WaitingForGetPinTryCounter");
}
private static bool VerifySDAD_CDA(KernelDatabase database, CAPublicKeyCertificate capk, CardResponse cardResponse, bool isFirstGenAC)
{
ICCDynamicData iccdd = VerifySAD.VerifySDAD(ICCDynamicDataType.NO_IDS_OR_RRP, isFirstGenAC, database, database.StaticDataToBeAuthenticated, capk, cardResponse);
if (iccdd == null)
{
return(false);
}
VerifySAD.AddSDADDataToDatabase(database, iccdd);
return(true);
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (database.IsScriptProcessingBeforeGenACInProgress)
{
if (cardResponse.ApduResponse.SW1 != 0x90 && cardResponse.ApduResponse.SW1 != 0x62 && cardResponse.ApduResponse.SW1 != 0x63)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.ScriptProcessingFailedBeforeFinalGENERATEAC = true;
tvr.UpdateDB();
database.IsScriptProcessingBeforeGenACInProgress = false;
return(CardActionAnalysis.Initiate2ndCardActionAnalysis(database, qManager, cardQManager, emvSelectApplicationResponse));
}
if (database.ScriptsToRunBeforeGenAC.Count == 0)
{
database.IsScriptProcessingBeforeGenACInProgress = false;
return(CardActionAnalysis.Initiate2ndCardActionAnalysis(database, qManager, cardQManager, emvSelectApplicationResponse, true));
}
TLV firstScript = database.ScriptsToRunBeforeGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
else
{
if (cardResponse.ApduResponse.SW1 != 0x90 && cardResponse.ApduResponse.SW1 != 0x62 && cardResponse.ApduResponse.SW1 != 0x63)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.ScriptProcessingFailedAfterFinalGENERATEAC = true;
tvr.UpdateDB();
//update emv data to return with this updated value
if (database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2) != null)
{
database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2).Children.RemoveFromList(database.Get(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN.Tag));
database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2).Children.AddToList(TLV.Create(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN.Tag, database.Get(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN).Value));
}
return(SignalsEnum.STOP);
}
if (database.ScriptsToRunAfterGenAC.Count == 0)
{
return(SignalsEnum.STOP);
}
TLV firstScript = database.ScriptsToRunAfterGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, PublicKeyCertificateManager pkcm, EMVSelectApplicationResponse emvSelectApplicationResponse, Stopwatch sw)
{
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
EMVGetChallengeResponse response = (EMVGetChallengeResponse)cardResponse.ApduResponse;
if (!response.Succeeded)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//store the challenge
byte[] pinChallenge = response.ResponseData;
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICCAndSignature_Paper)
{
string aid = emvSelectApplicationResponse.GetDFName();
string rid = aid.Substring(0, 10);
RIDEnum ridEnum = (RIDEnum)Enum.Parse(typeof(RIDEnum), rid);
CAPublicKeyCertificate capk = pkcm.GetCAPK(ridEnum, database.Get(EMVTagsEnum.CERTIFICATION_AUTHORITY_PUBLIC_KEY_INDEX_8F_KRN).Value[0]);
if (capk == null)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
byte[] pinBlock = PinProcessing.BuildPlainTextPinBlock(pin);
//encrypt the pin
byte[] encipheredPin = PinProcessing.BuildPinVerifyData(database, capk, pinBlock, pinChallenge);
if (encipheredPin == null)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//fire off verify for enciphered pin
EMVVerifyRequest request = new EMVVerifyRequest(VerifyCommandDataQualifier.Enciphered_PIN, encipheredPin);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
}
//verify message for plain text pin fired in waiting for pin response
return(SignalsEnum.WAITING_FOR_VERIFY);
}
private static SignalsEnum DoInvalidReponse(KernelDatabase 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,
null,
l2Enum,
l3Enum));
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.N_A,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
EMVInternalAuthenticateResponse response = cardResponse.ApduResponse as EMVInternalAuthenticateResponse;
string aid = emvSelectApplicationResponse.GetDFName();
string rid = aid.Substring(0, 10);
RIDEnum ridEnum = (RIDEnum)Enum.Parse(typeof(RIDEnum), rid);
CAPublicKeyCertificate capk = database.PublicKeyCertificateManager.GetCAPK(ridEnum, database.Get(EMVTagsEnum.CERTIFICATION_AUTHORITY_PUBLIC_KEY_INDEX_8F_KRN).Value[0]);
#region 3.8.1.1
bool ddaPassed = DoDDA(database, qManager, capk, response.GetTLVSignedApplicationData());
#endregion
if (!ddaPassed)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.DDAFailed = true;
tvr.UpdateDB();
}
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 = database.ACType.Value.DSACTypeEnum;
rcpST.Value.CDASignatureRequested = false;
rcpST.UpdateDB();
EMVGenerateACRequest request = new EMVGenerateACRequest(database.Get(EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2), null, rcpST);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GEN_AC_1);
}
private static SignalsEnum EntryPointL1RSP(KernelDatabase 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 SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw)
{
EMVVerifyResponse response = (EMVVerifyResponse)cardResponse.ApduResponse;
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
if (!response.Succeeded)
{
cvr.Value.CVMResult = 0x01;//failed
}
else
{
cvr.Value.CVMResult = 0x02; //successful
}
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
private static SignalsEnum EntryPointL1RSP(KernelDatabase database, CardResponse cardResponse, KernelQ qManager)
{
CommonRoutines.CreateEMVDiscretionaryData(database);
CommonRoutines.CreateEMVDataRecord(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,
cardResponse.L1Enum,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
}
public static SignalsEnum DoInvalidResponsePart_C(KernelDatabase database, KernelQ qManager, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
CommonRoutines.UpdateUserInterfaceRequestData(database, KernelMessageidentifierEnum.ERROR_OTHER_CARD, KernelStatusEnum.NOT_READY);
CommonRoutines.CreateEMVDiscretionaryData(database);
CommonRoutines.CreateEMVDataRecord(database);
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));
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.IssuerAuthenticationFailed = true;
tvr.UpdateDB();
}
else
{
TRANSACTION_STATUS_INFORMATION_9B_KRN tsi = new TRANSACTION_STATUS_INFORMATION_9B_KRN(database);
tsi.Value.IssuerAuthenticationWasPerformed = true;
tsi.UpdateDB();
}
//EMVExternalAuthenticateResponse response = cardResponse.ApduResponse as EMVExternalAuthenticateResponse;
//if scripts need to be run before gen ac, do now
return(CardActionAnalysis.Initiate2ndCardActionAnalysis(database, qManager, cardQManager, emvSelectApplicationResponse));
}
public static SignalsEnum Execute(
KernelDatabase database,
KernelQ qManager,
CardQ cardQManager,
EMVSelectApplicationResponse emvSelectApplicationResponse,
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));
case KernelTerminalReaderServiceRequestEnum.ONLINE:
return(EntryPointOnline(database, kernel1Request, qManager, cardQManager, emvSelectApplicationResponse));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in State_8_WaitingForOnlineAuth:" + 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));
case CardInterfaceServiceResponseEnum.L1RSP:
return(EntryPointL1RSP(database, cardResponse, qManager));
default:
throw new EMVProtocolException("Invalid Kernel1CardinterfaceServiceResponseEnum in State_8_WaitingForOnlineAuth:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
private static SignalsEnum DoCommonProcessing(string source, KernelDatabase database, KernelQ qManager, CardQ cardQManager, CardResponse cardResponse)
{
TLV nextTLV = database.TagsToReadYet.GetNextGetDataTagFromList();
if (nextTLV != null)
{
database.ActiveTag = nextTLV.Tag.TagLable;
}
else
{
database.ActiveTag = null;
}
if (database.ActiveTag != null)
{
EMVGetDataRequest request = new EMVGetDataRequest(Formatting.HexStringToByteArray(database.ActiveTag));
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
database.NextCommandEnum = NextCommandEnum.GET_DATA;
}
else
{
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;
}
}
TLVList dataToSend = database.Get(EMVTagsEnum.DATA_TO_SEND_FF8104_KRN2).Children;
APPLICATION_INTERCHANGE_PROFILE_82_KRN aip = new APPLICATION_INTERCHANGE_PROFILE_82_KRN(database);
TERMINAL_CAPABILITIES_9F33_KRN tc = new TERMINAL_CAPABILITIES_9F33_KRN(database);
return(SignalsEnum.WAITING_FOR_EMV_READ_RECORD_RESPONSE);
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw)
{
EMVGetDataResponse response = (EMVGetDataResponse)cardResponse.ApduResponse;
if (!response.Succeeded)
{
if (response.SW1 == 0x6A && response.SW2 == 0x88) //data not found
{
//do nothing
return(SignalsEnum.WAITING_FOR_TERMINAL_RISK_MANAGEMENT);
}
else
{
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,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
}
if (response.GetResponseTag().Tag.TagLable == EMVTagsEnum.APPLICATION_TRANSACTION_COUNTER_ATC_9F36_KRN.Tag)
{
database.AddToList(response.GetResponseTag());
}
if (response.GetResponseTag().Tag.TagLable == EMVTagsEnum.LAST_ONLINE_APPLICATION_TRANSACTION_COUNTER_ATC_REGISTER_9F13_KRN.Tag)
{
database.AddToList(response.GetResponseTag());
}
return(SignalsEnum.WAITING_FOR_TERMINAL_RISK_MANAGEMENT);
}
public static bool DoCDA(KernelDatabase database, KernelQ qManager, CAPublicKeyCertificate capk, CardQ cardQManager, CardResponse cardResponse, EMVSelectApplicationResponse emvSelectApplicationResponse, bool isFirstGenAC)
{
//#region 9_10.2
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
TRANSACTION_STATUS_INFORMATION_9B_KRN tsi = new TRANSACTION_STATUS_INFORMATION_9B_KRN(database);
tsi.Value.OfflineDataAuthenticationWasPerformed = true;
tsi.UpdateDB();
bool cdaSucceeded = VerifySDAD_CDA(database, capk, cardResponse, isFirstGenAC);
if (!cdaSucceeded)
{
tvr.Value.CDAFailed = true;
tvr.UpdateDB();
return(false);
}
else
{
return(true);
}
}
public static SignalsEnum Execute(
KernelDatabase 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 State_2_WaitingForPDOLData:" + Enum.GetName(typeof(KernelTerminalReaderServiceRequestEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
private static void UpdateStaticDataToBeAuthenticated(KernelDatabase 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();
}
}
}
}
private static SignalsEnum EntryPointDET(KernelDatabase database, KernelRequest kernel1Request)
{
database.UpdateWithDETData(kernel1Request.InputData);
return(SignalsEnum.WAITING_FOR_GPO_REPONSE);
}
private static SignalsEnum EntryPointSTOP(KernelDatabase database, KernelQ qManager)
{
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcomeWithError(database, qManager, Kernel2OutcomeStatusEnum.END_APPLICATION, Kernel2StartEnum.N_A, L1Enum.NOT_SET, L2Enum.NOT_SET, L3Enum.STOP));
}
private static SignalsEnum EntryPointDET(KernelDatabase database, KernelRequest kernel1Request)
{
database.UpdateWithDETData(kernel1Request.InputData);
return(SignalsEnum.WAITING_FOR_GET_PIN_TRY_COUNTER);
}
private static SignalsEnum EntryPointL1RSP(KernelDatabase database, CardResponse cardResponse, KernelQ qManager)
{
return(CommonRoutines.PostOutcomeWithError(database, qManager, Kernel2OutcomeStatusEnum.TRY_AGAIN, Kernel2StartEnum.B, cardResponse.L1Enum, L2Enum.NOT_SET, L3Enum.NOT_SET));
}
private static SignalsEnum EntryPointDET(KernelDatabase database, KernelRequest kernel1Request)
{
database.UpdateWithDETData(kernel1Request.InputData);
return(SignalsEnum.WAITING_FOR_EXTERNAL_AUTHENTICATE);
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
KernelStatusEnum.NOT_READY,
null,
Kernel2OutcomeStatusEnum.SELECT_NEXT,
Kernel2StartEnum.C,
null,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET, cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
bool parsingResult = false;
EMVGetProcessingOptionsResponse response = cardResponse.ApduResponse as EMVGetProcessingOptionsResponse;
if (cardResponse.ApduResponse.ResponseData.Length > 0 && cardResponse.ApduResponse.ResponseData[0] == 0x77)
{
parsingResult = database.ParseAndStoreCardResponse(response.ResponseData);
}
else
{
if (cardResponse.ApduResponse.ResponseData.Length > 0 && cardResponse.ApduResponse.ResponseData[0] == 0x80)
{
//if (cardResponse.ApduResponse.ResponseData.Length < 6 ||
// ((cardResponse.ApduResponse.ResponseData.Length - 2) % 4 != 0) ||
// database.IsNotEmpty(EMVTagsEnum.APPLICATION_INTERCHANGE_PROFILE_82_KRN.Tag) ||
// database.IsNotEmpty(EMVTagsEnum.APPLICATION_FILE_LOCATOR_AFL_94_KRN.Tag))
//{
// parsingResult = false;
//}
//else
//{
foreach (TLV tlv in response.GetResponseTags())
{
parsingResult = database.ParseAndStoreCardResponse(tlv);
if (!parsingResult)
{
break;
}
}
//}
}
}
if (!parsingResult)
{
return(DoInvalidReponse(database, qManager, L1Enum.NOT_SET, L2Enum.PARSING_ERROR, L3Enum.NOT_SET));
}
else
{
if (!(database.IsNotEmpty(EMVTagsEnum.APPLICATION_INTERCHANGE_PROFILE_82_KRN.Tag)) &&
database.IsNotEmpty(EMVTagsEnum.APPLICATION_FILE_LOCATOR_AFL_94_KRN.Tag))
{
return(DoInvalidReponse(database, qManager, L1Enum.NOT_SET, L2Enum.CARD_DATA_MISSING, L3Enum.NOT_SET));
}
else
{
return(DoEMVMode(database, qManager, cardQManager, cardResponse, sw));
}
}
}
