public void TestSingleLengthDesCalculator()
{
HexKey k = GetRandomKey(HexKey.KeyLength.SingleLength);
Assert.AreEqual("Encrypted: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES)) + System.Environment.NewLine + "Decrypted: " + Breakup(TripleDES.TripleDESDecrypt(k, ZEROES)),
TestCommand(new string[] { k.ToString(), ZEROES }, new SingleLengthDESCalculator_N()));
}
public override string ProcessMessage()
{
LMKPairs.LMKPair LMKKeyPair = LMKPairs.LMKPair.Null;
string var = "";
KeySchemeTable.KeyScheme ks = KeySchemeTable.KeyScheme.Unspecified;
HexKey.KeyLength kl = HexKey.KeyLength.SingleLength;
KeySchemeTable.KeyScheme zmkKS = KeySchemeTable.KeyScheme.Unspecified;
HexKey.KeyLength zmkKL;
string cryptKey = m_inStack.PopFromStack().ConsoleMessageProperty;
string cryptZMK = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyScheme = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyType = m_inStack.PopFromStack().ConsoleMessageProperty;
ExtractKeySchemeAndLength(cryptZMK, out zmkKL, out zmkKS);
ExtractKeySchemeAndLength(cryptKey, out kl, out ks);
ValidateKeyTypeCode(keyType, out LMKKeyPair, out var);
string clearZMK = Utility.DecryptZMKEncryptedUnderLMK(new HexKey(cryptZMK).ToString(), zmkKS, 0);
string clearKey = Utility.DecryptUnderLMK(new HexKey(cryptKey).ToString(), ks, LMKKeyPair, var);
string cryptUnderZMK = Utility.EncryptUnderZMK(clearZMK, new HexKey(clearKey).ToString(), KeySchemeTable.GetKeySchemeFromValue(keyScheme));
string chkVal = TripleDES.TripleDESEncrypt(new HexKey(clearKey), ZEROES);
return("Key encrypted under ZMK: " + MakeKeyPresentable(cryptUnderZMK) + System.Environment.NewLine +
"Key Check Value: " + MakeCheckValuePresentable(chkVal));
}
public override string ProcessMessage()
{
string data = m_inStack.PopFromStack().ConsoleMessageProperty;
string length = m_inStack.PopFromStack().ConsoleMessageProperty;
string desKey = m_inStack.PopFromStack().ConsoleMessageProperty;
if (desKey.Length != 48)
{
return("INVALID KEY");
}
if (Utility.IsParityOK(desKey, Utility.ParityCheck.OddParity) == false)
{
return("KEY PARITY ERROR");
}
if (((data.Length == 16) && (length != "S")) ||
((data.Length == 32) && (length != "D")) ||
((data.Length == 48) && (length != "T")))
{
return("INVALID DATA LENGTH");
}
HexKey hk = new HexKey(desKey);
string crypt = TripleDES.TripleDESEncrypt(hk, data);
string decrypt = TripleDES.TripleDESDecrypt(hk, data);
return("Encrypted: " + MakeKeyPresentable(crypt) + System.Environment.NewLine + "Decrypted: " + MakeKeyPresentable(decrypt));
}
public override string ProcessMessage()
{
LMKPairs.LMKPair LMKKeyPair; string var = "";
KeySchemeTable.KeyScheme ks;
HexKey.KeyLength kl;
KeySchemeTable.KeyScheme zmkKS;
HexKey.KeyLength zmkKL;
string cryptKey = m_inStack.PopFromStack().ConsoleMessageProperty;
string cryptZMK = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyScheme = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyType = m_inStack.PopFromStack().ConsoleMessageProperty;
ExtractKeySchemeAndLength(cryptZMK, out zmkKL, out zmkKS);
ExtractKeySchemeAndLength(cryptKey, out kl, out ks);
ValidateKeyTypeCode(keyType, out LMKKeyPair, out var);
if ((ks == KeySchemeTable.KeyScheme.DoubleLengthKeyVariant) || (ks == KeySchemeTable.KeyScheme.TripleLengthKeyVariant))
{
return("INVALID KEY SCHEME FOR ENCRYPTED KEY - MUST BE ANSI");
}
string clearZMK = Utility.DecryptZMKEncryptedUnderLMK(new HexKey(cryptZMK).ToString(), zmkKS, 0);
string clearKey = TripleDES.TripleDESDecrypt(new HexKey(clearZMK), new HexKey(cryptKey).ToString());
string cryptUnderLMK = Utility.EncryptUnderLMK(clearKey, KeySchemeTable.GetKeySchemeFromValue(keyScheme), LMKKeyPair, var);
string chkVal = TripleDES.TripleDESEncrypt(new HexKey(clearKey), ZEROES);
return("Key under LMK: " + MakeKeyPresentable(cryptUnderLMK) + System.Environment.NewLine +
"Key Check Value: " + MakeCheckValuePresentable(chkVal));
}
protected string GenerateCVV(string CVKPair, string AccountNumber, string ExpirationDate, string SVC)
{
string CVKA = Utility.RemoveKeyType(CVKPair).Substring(0, 16);
string CVKB = Utility.RemoveKeyType(CVKPair).Substring(16);
string block = (AccountNumber + ExpirationDate + SVC).PadRight(32, '0');
string blockA = block.Substring(0, 16);
string blockB = block.Substring(16);
string result = TripleDES.TripleDESEncrypt(new HexKey(CVKA), blockA);
result = Utility.XORHexStrings(result, blockB);
result = TripleDES.TripleDESEncrypt(new HexKey(CVKA + CVKB), result);
string CVV = ""; int i = 0;
while (CVV.Length < 3)
{
if (Char.IsDigit(result[i]))
{
CVV += result.Substring(i, 1);
}
i += 1;
}
return(CVV);
}
public void TestTripleDES()
{
string sResult = TripleDES.TripleDESEncrypt(new HexKey("0123456789ABCDEFABCDEF0123456789"), ZEROES);
Assert.AreEqual(sResult, "EE21F1F01A3D7C9A");
string sResult2 = TripleDES.TripleDESDecrypt(new HexKey("0123456789ABCDEFABCDEF0123456789"), sResult);
Assert.AreEqual(sResult2, ZEROES);
}
public void TestFormKeyFromComponents()
{
AuthorizedStateOn();
HexKey cmp1 = GetRandomKey(HexKey.KeyLength.DoubleLength);
HexKey cmp2 = GetRandomKey(HexKey.KeyLength.DoubleLength);
HexKey cmp3 = GetRandomKey(HexKey.KeyLength.DoubleLength);
HexKey zmk = new HexKey(Utility.XORHexStringsFull(Utility.XORHexStringsFull(cmp1.ToString(), cmp2.ToString()), cmp3.ToString()));
string cryptZMK = Utility.EncryptUnderLMK(zmk.ToString(), KeySchemeTable.KeyScheme.DoubleLengthKeyVariant, LMKPairs.LMKPair.Pair04_05, "0");
Assert.AreEqual("Encrypted key: " + Breakup(cryptZMK) + System.Environment.NewLine +
"Key check value: " + Breakup(TripleDES.TripleDESEncrypt(zmk, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "2", "000", "U", "X", "3", cmp1.ToString(), cmp2.ToString(), cmp3.ToString() }, new FormKeyFromComponents_FK()));
}
public void TestExportKey()
{
HexKey k = null;
HexKey ZMK = null;
string cryptZMK = "";
string cryptKey = "";
string cryptUnderZMK = "";
GenerateTestKeyAndZMKKey(out k, LMKPairs.LMKPair.Pair06_07, KeySchemeTable.KeyScheme.DoubleLengthKeyVariant, out ZMK, out cryptZMK, out cryptKey, out cryptUnderZMK);
Assert.AreEqual("Key encrypted under ZMK: " + Breakup(cryptUnderZMK) + System.Environment.NewLine +
"Key Check Value: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "001", "U", cryptZMK, cryptKey }, new ExportKey_KE()));
}
public void TestImportKey()
{
AuthorizedStateOn();
HexKey k;
HexKey ZMK;
string cryptZMK = "";
string cryptKey = "";
string cryptUnderZMK = "";
GenerateTestKeyAndZMKKey(out k, LMKPairs.LMKPair.Pair06_07, KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi, out ZMK, out cryptZMK, out cryptKey, out cryptUnderZMK);
Assert.AreEqual("Key under LMK: " + Breakup(cryptKey) + System.Environment.NewLine +
"Key Check Value: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "001", "X", cryptZMK, cryptUnderZMK }, new ImportKey_IK()));
}
private static string GetNaturalPin(string cardPan, string pin)
{
string acctNo = cardPan.Substring(cardPan.Length - 13, 12);
string pinValData = cardPan.Substring(0, 10) + "N" + cardPan.Last();
string expPinValData = pinValData.Substring(0, pinValData.IndexOf("N"));
expPinValData = expPinValData + acctNo.Substring(acctNo.Length - 5, 5);
expPinValData = expPinValData + pinValData.Substring(pinValData.IndexOf("N") + 1, (pinValData.Length - (pinValData.IndexOf("N") + 1)));
// The PVK is a double-length key, so we need to do a 3DES-decrypt.
string cryptAcctNum = TripleDES.TripleDESEncrypt(new HexKey(ConfigurationManager.HsmConfig.PinVerificationKey), expPinValData);
string decimalisedAcctNum = Utility.Decimalise(cryptAcctNum, ConfigurationManager.HsmConfig.DecimalisationTable);
string naturalPin = decimalisedAcctNum.Substring(0, pin.Length);
return(naturalPin);
}
public void TestEncryptClearComponent()
{
AuthorizedStateOn();
HexKey k = GetRandomKey(HexKey.KeyLength.DoubleLength);
Assert.AreEqual("Encrypted Component: " + Breakup(Utility.EncryptUnderLMK(k.ToString(), KeySchemeTable.KeyScheme.DoubleLengthKeyVariant, LMKPairs.LMKPair.Pair04_05, "0")) + System.Environment.NewLine +
"Key check value: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "000", "U", k.ToString() }, new EncryptClearComponent_EC()));
Assert.AreEqual("Encrypted Component: " + Breakup(Utility.EncryptUnderLMK(k.ToString(), KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi, LMKPairs.LMKPair.Pair06_07, "0")) + System.Environment.NewLine +
"Key check value: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "001", "X", k.ToString() }, new EncryptClearComponent_EC()));
k = GetRandomKey(HexKey.KeyLength.TripleLength);
Assert.AreEqual("Encrypted Component: " + Breakup(Utility.EncryptUnderLMK(k.ToString(), KeySchemeTable.KeyScheme.TripleLengthKeyAnsi, LMKPairs.LMKPair.Pair26_27, "0")) + System.Environment.NewLine +
"Key check value: " + Breakup(TripleDES.TripleDESEncrypt(k, ZEROES).Substring(0, 6)),
TestCommand(new string[] { "008", "Y", k.ToString() }, new EncryptClearComponent_EC()));
}
public override string ProcessMessage()
{
string[] components = new string[8];
int idx = 0;
while (true)
{
ConsoleMessage msg = m_inStack.PopFromStack();
if (msg.IsNumberOfComponents == false)
{
components[idx] = msg.ConsoleMessageProperty;
idx += 1;
}
else
{
break;
}
}
if (AllSameLength(components, idx) == false)
{
throw new Exception("DATA INVALID; ALL KEYS MUST BE OF THE SAME LENGTH");
}
if (components[0].Length == 48)
{
throw new Exception("TRIPLE LENGTH COMPONENT NOT SUPPORTED");
}
string[] clearKeys = new string[idx];
KeySchemeTable.KeyScheme ks = new HexKey(components[0]).Scheme;
for (int i = 0; i < idx; i++)
{
clearKeys[i] = Utility.DecryptZMKEncryptedUnderLMK(components[i], ks, 0);
}
HexKey finalKey = new HexKey(XORAllKeys(clearKeys));
finalKey = new HexKey(Utility.MakeParity(finalKey.ToString(), Utility.ParityCheck.OddParity));
string cryptKey = Utility.EncryptUnderLMK(finalKey.ToString(), ks, LMKPairs.LMKPair.Pair04_05, "0");
string chkVal = TripleDES.TripleDESEncrypt(finalKey, ZEROES);
return("Encrypted key: " + MakeKeyPresentable(cryptKey) + System.Environment.NewLine +
"Key check value: " + MakeCheckValuePresentable(chkVal));
}
private void MACBytes(byte[] b, int curIndex, string IV, string key, string result)
{
string dataStr = "";
while (dataStr.Length != 16)
{
if (curIndex <= b.GetUpperBound(0))
{
dataStr = dataStr + b[curIndex].ToString("X2");
curIndex += 1;
}
else
{
dataStr = dataStr.PadRight(16, '0');
}
}
dataStr = Utility.XORHexStringsFull(dataStr, IV);
result = TripleDES.TripleDESEncrypt(new HexKey(key), dataStr);
}
public static string EncryptUnderZMK(string clearZMK, string clearData, KeySchemeTable.KeyScheme ZMK_KeyScheme, string AtallaVariant)
{
string result = "";
clearZMK = Utility.TransformUsingAtallaVariant(clearZMK, AtallaVariant);
switch (ZMK_KeyScheme)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.Unspecified:
result = TripleDES.TripleDESEncrypt(new HexKey(clearZMK), clearData);
break;
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
result = TripleDES.TripleDESEncryptVariant(new HexKey(clearZMK), clearData);
break;
default:
break;
}
switch (ZMK_KeyScheme)
{
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
result = KeySchemeTable.GetKeySchemeValue(ZMK_KeyScheme) + result;
break;
default:
break;
}
return(result);
}
public static string EncryptUnderLMK(string clearKey, KeySchemeTable.KeyScheme Target_KeyScheme, LMKPairs.LMKPair LMKKeyPair, string variantNumber)
{
string result = "";
switch (Target_KeyScheme)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.Unspecified:
result = TripleDES.TripleDESEncrypt(new HexKey(Cryptography.LMK.LMKStorage.LMKVariant(LMKKeyPair, Convert.ToInt32(variantNumber))), clearKey);
break;
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
result = TripleDES.TripleDESEncryptVariant(new HexKey(Cryptography.LMK.LMKStorage.LMKVariant(LMKKeyPair, Convert.ToInt32(variantNumber))), clearKey);
break;
default:
//throw new InvalidOperationException("Invalid key scheme [" + Target_KeyScheme.ToString() + "]");
break;
}
switch (Target_KeyScheme)
{
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
result = KeySchemeTable.GetKeySchemeValue(Target_KeyScheme) + result;
break;
default:
break;
}
return(result);
}
public override string ProcessMessage()
{
LMKPairs.LMKPair LMKKeyPair;
string var = "";
KeySchemeTable.KeyScheme ks;
string clearComponent = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyScheme = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyType = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyLen;
switch (clearComponent.Length)
{
case 16:
keyLen = "1";
break;
case 32:
keyLen = "2";
break;
default:
keyLen = "3";
break;
}
ValidateKeySchemeAndLength(keyLen, keyScheme, out ks);
ValidateKeyTypeCode(keyType, out LMKKeyPair, out var);
clearComponent = Utility.MakeParity(clearComponent, Utility.ParityCheck.OddParity);
string cryptKey = Utility.EncryptUnderLMK(clearComponent, ks, LMKKeyPair, var);
string chkVal = TripleDES.TripleDESEncrypt(new HexKey(clearComponent), ZEROES);
return("Encrypted Component: " + MakeKeyPresentable(cryptKey) + System.Environment.NewLine +
"Key check value: " + MakeCheckValuePresentable(chkVal));
}
protected string GeneratePVV(string AccountNumber, string PVKI, string PIN, string PVKPair)
{
string stage1 = AccountNumber.Substring(1, 11) + PVKI + PIN.Substring(0, 4);
string stage2 = TripleDES.TripleDESEncrypt(new ThalesCore.Cryptography.HexKey(PVKPair), stage1);
string PVV = ""; int i;
while (PVV.Length < 4)
{
i = 0;
while ((PVV.Length < 4) && (i < stage2.Length))
{
if (Char.IsDigit(stage2[i]))
{
PVV += stage2.Substring(i, 1);
i += 1;
}
}
if (PVV.Length < 4)
{
for (int j = 0; j < stage2.Length; j++)
{
string newChar = " ";
if (Char.IsDigit(stage2[j]) == false)
{
newChar = (Convert.ToInt32(stage2.Substring(j, 1), 16) - 10).ToString("X");
}
stage2 = stage2.Remove(j, 1);
stage2 = stage2.Insert(j, newChar);
}
stage2 = stage2.Replace(" ", "");
}
}
return(PVV);
}
public override string ProcessMessage()
{
LMKPairs.LMKPair LMKKeyPair;
string var = "";
KeySchemeTable.KeyScheme ks;
string[] components = new string[8];
int idx = 0;
while (true)
{
ConsoleMessage msg = m_inStack.PopFromStack();
if (msg.IsNumberOfComponents == false)
{
components[idx] = msg.ConsoleMessageProperty;
idx += 1;
}
else
{
break;
}
}
string compType = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyScheme = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyType = m_inStack.PopFromStack().ConsoleMessageProperty;
string keyLen = m_inStack.PopFromStack().ConsoleMessageProperty;
ValidateKeySchemeAndLength(keyLen, keyScheme, out ks);
ValidateKeyTypeCode(keyType, out LMKKeyPair, out var);
if (AllSameLength(components, idx) == false)
{
throw new Exception("DATA INVALID; ALL KEYS MUST BE OF THE SAME LENGTH");
}
if (compType == CLEAR_XOR_KEYS)
{
switch (ks)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
if (components[0].Length != 16)
{
throw new Exception("DATA INVALID; KEYS MUST BE 16 HEX CHARACTERS");
}
break;
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
if (components[0].Length != 32)
{
throw new Exception("DATA INVALID; KEYS MUST BE 32 HEX CHARACTERS");
}
break;
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
if (components[0].Length != 48)
{
throw new Exception("DATA INVALID; KEYS MUST BE 48 HEX CHARACTERS");
}
break;
}
}
if (compType == HALF_THIRD_KEYS)
{
switch (ks)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
if (components[0].Length != 8)
{
throw new Exception("DATA INVALID; SINGLE-LENGTH HALF-KEYS MUST BE 8 HEX CHARACTERS");
}
if (idx != 2)
{
throw new Exception("DATA INVALID; THERE MUST BE 2 HALF-KEYS");
}
break;
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
if (components[0].Length != 16)
{
throw new Exception("DATA INVALID; DOUBLE-LENGTH HALF-KEYS MUST BE 16 HEX CHARACTERS");
}
if (idx != 2)
{
throw new Exception("DATA INVALID; THERE MUST BE 2 HALF-KEYS");
}
break;
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
if (components[0].Length != 16)
{
throw new Exception("DATA INVALID; TRIPLE-LENGTH THIRD-KEYS MUST BE 16 HEX CHARACTERS");
}
if (idx != 3)
{
throw new Exception("DATA INVALID; THERE MUST BE 3 THIRD-KEYS");
}
break;
}
}
if (compType == ENCRYPTED_KEYS)
{
switch (ks)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
if (components[0].Length != 16)
{
throw new Exception("DATA INVALID; SINGLE-LENGTH ENCRYPTED COMPONENTS MUST BE 16 HEX CHARACTERS");
}
break;
case KeySchemeTable.KeyScheme.DoubleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.DoubleLengthKeyVariant:
if (components[0].Length != 33)
{
throw new Exception("DATA INVALID; DOUBLE-LENGTH ENCRYPTED COMPONENTS MUST BE KEY SCHEME AND 32 HEX CHARACTERS");
}
if (AllSameStartChar(components, idx) == false)
{
throw new Exception("DATA INVALID; DOUBLE-LENGTH ENCRYPTED COMPONENTS MUST ALL USE SAME KEY SCHEME");
}
break;
case KeySchemeTable.KeyScheme.TripleLengthKeyAnsi:
case KeySchemeTable.KeyScheme.TripleLengthKeyVariant:
if (components[0].Length != 49)
{
throw new Exception("DATA INVALID; TRIPLE-LENGTH ENCRYPTED COMPONENTS MUST BE KEY SCHEME AND 48 HEX CHARACTERS");
}
if (AllSameStartChar(components, idx) == false)
{
throw new Exception("DATA INVALID; DOUBLE-LENGTH ENCRYPTED COMPONENTS MUST ALL USE SAME KEY SCHEME");
}
break;
}
}
HexKey finalKey = null;
switch (compType)
{
case HALF_THIRD_KEYS:
switch (ks)
{
case KeySchemeTable.KeyScheme.SingleDESKey:
finalKey = new HexKey(components[1] + components[0]);
break;
default:
string keyStr = "";
for (int i = components.GetUpperBound(0); i > -1; i++)
{
keyStr = keyStr + components[i];
}
finalKey = new HexKey(keyStr);
break;
}
break;
case CLEAR_XOR_KEYS:
finalKey = new HexKey(XORAllKeys(components, idx));
break;
case ENCRYPTED_KEYS:
string[] clearKeys = new string[idx - 1];
for (int i = 0; i < clearKeys.GetUpperBound(0); i++)
{
clearKeys[i] = Utility.DecryptUnderLMK(Utility.RemoveKeyType(components[i]), ks, LMKKeyPair, var);
}
finalKey = new HexKey(XORAllKeys(clearKeys, idx));
break;
}
finalKey = new HexKey(Utility.MakeParity(finalKey.ToString(), Utility.ParityCheck.OddParity));
string cryptKey = Utility.EncryptUnderLMK(finalKey.ToString(), ks, LMKKeyPair, var);
string chkVal = TripleDES.TripleDESEncrypt(finalKey, ZEROES);
return("Encrypted key: " + MakeKeyPresentable(cryptKey) + System.Environment.NewLine +
"Key check value: " + MakeCheckValuePresentable(chkVal));
}
public override MessageResponse ConstructResponse()
{
MessageResponse mr = new MessageResponse();
LMKPairs.LMKPair LMKKeyPair;
string var = "";
KeySchemeTable.KeyScheme ks = KeySchemeTable.KeyScheme.Unspecified;
KeySchemeTable.KeyScheme zmk_ks = KeySchemeTable.KeyScheme.Unspecified;
if (!ValidateKeyTypeCode(_keyType, out LMKKeyPair, ref var, ref mr))
{
return(mr);
}
if (!ValidateKeySchemeCode(_keyScheme, ref ks, ref mr))
{
return(mr);
}
if (_zmkScheme != "")
{
if (!ValidateKeySchemeCode(_zmkScheme, ref zmk_ks, ref mr))
{
return(mr);
}
}
if (!ValidateFunctionRequirement(KeyTypeTable.KeyFunction.Generate, LMKKeyPair, var, mr))
{
return(mr);
}
string rndKey = Utility.CreateRandomKey(ks);
string cryptRndKey = Utility.EncryptUnderLMK(rndKey, ks, LMKKeyPair, var);
string chkVal = TripleDES.TripleDESEncrypt(new HexKey(rndKey), Constants.ZEROES);
Log.Logger.MinorInfo("Key generated (clear): " + rndKey);
Log.Logger.MinorInfo("Key generated (LMK): " + cryptRndKey);
Log.Logger.MinorInfo("Check value: " + chkVal.Substring(0, 6));
string clearZMK;
string cryptUnderZMK = "";
if (_zmk != "")
{
HexKey cryptZMK = new HexKey(_zmk);
clearZMK = Utility.DecryptZMKEncryptedUnderLMK(cryptZMK.ToString(), cryptZMK.Scheme, 0);
if (!Utility.IsParityOK(clearZMK, Utility.ParityCheck.OddParity))
{
mr.AddElement(ErrorCodes.ER_10_SOURCE_KEY_PARITY_ERROR);
return(mr);
}
cryptUnderZMK = Utility.EncryptUnderZMK(clearZMK, rndKey, zmk_ks);
Log.Logger.MinorInfo("ZMK (clear): " + clearZMK);
Log.Logger.MinorInfo("Key under ZMK: " + cryptUnderZMK);
}
mr.AddElement(ErrorCodes.ER_00_NO_ERROR);
mr.AddElement(cryptRndKey);
mr.AddElement(cryptUnderZMK);
mr.AddElement(chkVal.Substring(0, 6));
return(mr);
}