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); }