public void X919MacTest()
{
var hk = new HexKey("838652DF68A246046DAB6104583B201A");
const string data = "30303030303030303131313131313131";
var iv = "0000000000000000";
// Binary data MACing.
var hexStr = ("00000000").GetBytes().GetHexString();
Assert.AreEqual("3F431586CA33D99C", IsoX919Mac.MacHexData(hexStr, hk, iv, IsoX919BlockType.OnlyBlock));
// Binary un-padded data MACing.
hexStr = ("000000001").GetBytes().GetHexString();
Assert.AreEqual("2FE7118F2074398E", IsoX919Mac.MacHexData(hexStr, hk, iv, IsoX919BlockType.OnlyBlock));
// Successive hex data MACing.
iv = IsoX919Mac.MacHexData(data, hk, iv, IsoX919BlockType.FirstBlock);
Assert.AreEqual("A9D4D96683B51333", iv);
iv = IsoX919Mac.MacHexData(data, hk, iv, IsoX919BlockType.NextBlock);
Assert.AreEqual("DA46CEC9E61AF065", iv);
iv = IsoX919Mac.MacHexData(data, hk, iv, IsoX919BlockType.NextBlock);
Assert.AreEqual("56A27E35442BD07D", iv);
iv = IsoX919Mac.MacHexData(data, hk, iv, IsoX919BlockType.NextBlock);
Assert.AreEqual("B12874BED7137303", iv);
iv = IsoX919Mac.MacHexData(data, hk, iv, IsoX919BlockType.FinalBlock);
Assert.AreEqual("0D99127F7734AA58", iv);
}
protected void ExtractKeySchemeAndLength(string key, out Cryptography.HexKey.KeyLength keyLen, out KeySchemeTable.KeyScheme keyScheme)
{
HexKey hk = new HexKey(key);
keyLen = hk.KeyLen;
keyScheme = hk.Scheme;
}
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 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 static string MacHexData(string dataStr, HexKey key, string IV, ISOX919Blocks block)
{
if (dataStr.Length % 16 != 0)
{
dataStr = Cryptography.MAC.ISO9797Pad.PadHexString(dataStr, Cryptography.MAC.ISO9797PaddingMethods.PaddingMethod1);
}
string result = dataStr;
for (int i = 0; i < (dataStr.Length / 16); i++)
{
IV = Utility.XORHexStringsFull(IV, dataStr.Substring(i * 16, 16));
IV = Cryptography.DES.DESEncrypt(key.PartA, IV);
}
result = IV;
if ((block == ISOX919Blocks.FinalBlock) || (block == ISOX919Blocks.OnlyBlock))
{
result = Cryptography.DES.DESDecrypt(key.PartB, IV);
result = Cryptography.DES.DESEncrypt(key.PartA, result);
}
return(result);
}
public static string TransformUsingAtallaVariant(string key, string AtallaVariant)
{
if ((AtallaVariant == String.Empty) || (AtallaVariant == ""))
{
return(key);
}
int var = Convert.ToInt32(AtallaVariant);
int varLen = (int)new System.ComponentModel.Int32Converter().ConvertFromString("0xH8") * var;
string varStr = String.Empty;
if (varLen != 8)
{
varStr = Convert.ToString(varLen, 16).PadRight(16, '0');
}
else
{
varStr = "08".PadRight(16, '0');
}
HexKey hKey = new HexKey(key);
hKey.PartA = Utility.XORHexStrings(hKey.PartA, varStr);
if (hKey.KeyLen != HexKey.KeyLength.SingleLength)
{
hKey.PartB = Utility.XORHexStrings(hKey.PartB, varStr);
if (hKey.KeyLen != HexKey.KeyLength.DoubleLength)
{
hKey.PartC = Utility.XORHexStrings(hKey.PartC, varStr);
}
}
return(hKey.ToString());
}
private void GenerateTestKeyAndZMKKey(out HexKey k, LMKPairs.LMKPair kLMK, KeySchemeTable.KeyScheme kScheme, out HexKey ZMK, out string cryptZMK, out string cryptKey, out string cryptUnderZMK)
{
k = GetRandomKey(HexKey.KeyLength.DoubleLength);
ZMK = GetRandomKey(HexKey.KeyLength.DoubleLength);
cryptZMK = Utility.EncryptUnderLMK(ZMK.ToString(), KeySchemeTable.KeyScheme.DoubleLengthKeyVariant, LMKPairs.LMKPair.Pair04_05, "0");
cryptKey = Utility.EncryptUnderLMK(k.ToString(), kScheme, kLMK, "0");
cryptUnderZMK = Utility.EncryptUnderZMK(ZMK.ToString(), k.ToString(), kScheme);
}
public void TranslateEncryptedPinBlock(string pinBlock, string accountOrPadding,
PinBlockFormat sourceFormat, PinBlockFormat targetFormat,
string sourceClearKey, string targetClearKey, string expected)
{
var pb = new PinBlock(pinBlock, accountOrPadding, sourceFormat, new HexKey(sourceClearKey));
var key = new HexKey(targetClearKey);
Assert.AreEqual(expected, pb.Translate(key, targetFormat));
}
public void VerifyHexKeyCreation(string hexKey, string expectedKey, KeyLength expectedLength, KeyScheme expectedScheme)
{
var key = new HexKey(hexKey);
Assert.AreEqual(expectedKey, key.Key);
Assert.AreEqual(expectedLength, key.Length);
Assert.AreEqual(expectedScheme, key.Scheme);
Assert.AreEqual(key.ToString().StripKeyScheme(), hexKey.ToUpper().StripKeyScheme());
}
public Hex GetHexAt(int x, int y, int z)
{
HexKey key = new HexKey(x, y, z);
if (hexHashMap.ContainsKey(key))
{
return(hexHashMap[key]);
}
return(null);
}
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 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 WindowsFormsHost_KeyDown(object sender, KeyEventArgs e)
{
HexKey key = HexKey.None;
switch (e.Key)
{
case Key.Q: key = HexKey.One; break;
case Key.W: key = HexKey.Two; break;
case Key.E: key = HexKey.Three; break;
case Key.R: key = HexKey.A; break;
case Key.T: key = HexKey.D; break;
case Key.A: key = HexKey.Four; break;
case Key.S: key = HexKey.Five; break;
case Key.D: key = HexKey.Six; break;
case Key.G: key = HexKey.E; break;
case Key.F: key = HexKey.B; break;
case Key.Z: key = HexKey.Seven; break;
case Key.X: key = HexKey.Eight; break;
case Key.C: key = HexKey.Nine; break;
case Key.V: key = HexKey.C; break;
case Key.B: key = HexKey.F; break;
case Key.Space: key = HexKey.Zero; break;
default: break;
}
m_Machine.PressedKey = key;
UpdatePressKeyLabel();
}
public void ValidateConsoleMessage(string consoleMsg)
{
consoleMsg = consoleMsg.ToUpper();
if ((ignoreEmptyKey) && (consoleMsg == ""))
{
return;
}
if ((Utility.IsHexString(consoleMsg) == false) || (consoleMsg.Length != 8))
{
try
{
HexKey key = new HexKey(consoleMsg);
}
catch (Exception ex)
{
throw new Exceptions.XInvalidKey("INVALID KEY");
}
}
}
public void TestX919Mac()
{
HexKey hk = new HexKey("838652DF68A246046DAB6104583B201A");
string strdata = "30303030303030303131313131313131";
string IV = "0000000000000000";
string hexString = String.Empty;
Utility.ByteArrayToHexString(Utility.GetBytesFromString("00000000"), out hexString);
Assert.AreEqual("3F431586CA33D99C", ISOX919MAC.MacHexData(hexString, hk, IV, ISOX919Blocks.OnlyBlock));
IV = ISOX919MAC.MacHexData(strdata, hk, IV, ISOX919Blocks.FirstBlock);
Assert.AreEqual("A9D4D96683B51333", IV);
IV = ISOX919MAC.MacHexData(strdata, hk, IV, ISOX919Blocks.NextBlock);
Assert.AreEqual("DA46CEC9E61AF065", IV);
IV = ISOX919MAC.MacHexData(strdata, hk, IV, ISOX919Blocks.NextBlock);
Assert.AreEqual("56A27E35442BD07D", IV);
IV = ISOX919MAC.MacHexData(strdata, hk, IV, ISOX919Blocks.NextBlock);
Assert.AreEqual("B12874BED7137303", IV);
IV = ISOX919MAC.MacHexData(strdata, hk, IV, ISOX919Blocks.FinalBlock);
Assert.AreEqual("0D99127F7734AA58", IV);
}
// Creates a hashmap for all the hexes to be accessed via this.GetHexAt()
private void InitializeHexes()
{
for (int i = 0; i < hexes.Length; i++)
{
Hex hex = hexes[i];
if (hex == null)
{
// Debug.Log("found null inbetween end");
continue;
}
HexKey key = new HexKey(hex.x, hex.y, hex.z);
if (hexHashMap.ContainsKey(key))
{
// Debug.Log("Hex Hash Map already contains key: ("+x + ", " + y + ", " + z + ")");
continue;
}
//Debug.Log("Added hex key: ("+x + ", " + y + ", " + z + ") to hex hash map");
hexHashMap.Add(key, hex);
}
}
/// <summary>
/// Calculates a MAC using the X9.19 algorithm.
/// </summary>
/// <param name="data">Hex data to MAC.</param>
/// <param name="key">MACing key.</param>
/// <param name="iv">Initial vector.</param>
/// <param name="blockType">Message block to MAC.</param>
/// <returns>MAC result.</returns>
public static string MacHexData(string data, HexKey key, string iv, IsoX919BlockType blockType)
{
if (data.Length % 16 != 0)
{
data = Iso9797Pad.PadHexString(data, Iso9797PaddingMethodType.PaddingMethod1);
}
for (var i = 0; i <= (data.Length / 16) - 1; i++)
{
iv = iv.XorHex(data.Substring(i * 16, 16));
iv = TripleDes.DesEncrypt(key.PartA, iv);
}
var result = iv;
if (blockType == IsoX919BlockType.FinalBlock || blockType == IsoX919BlockType.OnlyBlock)
{
result = TripleDes.DesDecrypt(key.PartB, iv);
result = TripleDes.DesEncrypt(key.PartA, result);
}
return(result);
}
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));
}
/// <summary>
/// Translate and encrypt PIN block.
/// </summary>
/// <param name="key">Clear encryption key.</param>
/// <param name="format">New PIN block format.</param>
/// <returns>Translated and encrypted PIN block.</returns>
public string Translate(HexKey key, PinBlockFormat format)
{
var newBlock = new PinBlock(Pin, AccountOrPadding, format);
return(key.Encrypt(newBlock.ClearPinBlock));
}
/// <summary>
/// Creates a new instance of this class form encrypted data.
/// </summary>
/// <param name="encryptedPinBlock">Encrypted PIN block.</param>
/// <param name="accountOrPadding">Account or padding string.</param>
/// <param name="format">PIN block format.</param>
/// <param name="clearKey">Clear encryption key.</param>
public PinBlock(string encryptedPinBlock, string accountOrPadding, PinBlockFormat format, HexKey clearKey)
{
AccountOrPadding = accountOrPadding;
Format = format;
ClearPinBlock = clearKey.Decrypt(encryptedPinBlock);
Pin = ClearPinBlock.GetPin(accountOrPadding, format);
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
var cryptKey = new HexKey(_key);
if ((cryptKey.Length == KeyLength.SingleLength && _keyLength != KeySingle) ||
(cryptKey.Length == KeyLength.DoubleLength && _keyLength != KeyDouble))
{
mr.Append(ErrorCodes.ER_04_INVALID_KEY_TYPE_CODE);
return(mr);
}
var len = Convert.ToInt32(_msgLength, 16);
if (_messageType == InputHex)
{
len = len * 2;
}
if (_strMsg.Length < len)
{
mr.Append(ErrorCodes.ER_80_DATA_LENGTH_ERROR);
return(mr);
}
var rawData = _messageType == InputHex
? _strMsg.Substring(0, len)
: _strMsg.Substring(0, len).GetBytes().GetHexString();
var clearKey = _keyType == KeyTak
? new HexKeyThales(new KeyTypeCode(0, LmkPair.Pair16_17), false, _key)
: new HexKeyThales(new KeyTypeCode(0, LmkPair.Pair26_27), false, _key);
var block = IsoX919BlockType.FinalBlock;
switch (_blockNumber)
{
case MacSingleBlock:
block = IsoX919BlockType.OnlyBlock;
_iv = Zeroes;
break;
case MacFirstBlock:
block = IsoX919BlockType.FirstBlock;
_iv = Zeroes;
break;
case MacMiddleBlock:
block = IsoX919BlockType.NextBlock;
break;
}
var mac = IsoX919Mac.MacHexData(rawData, clearKey.ClearHexKey, _iv, block);
Log.InfoFormat("Key (clear): {0}", clearKey.ClearKey);
Log.InfoFormat("IV: {0}", _iv);
Log.InfoFormat("Resulting MAC: {0}", mac);
mr.Append(ErrorCodes.ER_00_NO_ERROR);
mr.Append(mac);
return(mr);
}
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);
}
