public void TestKeyTypeCode(string keyTypeCode, LmkPair expectedPair, int expectedVariant)
{
var ktc = new KeyTypeCode(keyTypeCode);
Assert.AreEqual(expectedPair, ktc.Pair);
Assert.AreEqual(expectedVariant, ktc.Variant);
Assert.AreEqual(ktc.ToString(), keyTypeCode);
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
KeyTypeCode ktc = null;
if (!ValidateKeyTypeCode(_keyTypeCode, mr, ref ktc))
{
return(mr);
}
var lmkKs = KeyScheme.Unspecified;
if (!ValidateKeySchemeCode(_lmkScheme, mr, ref lmkKs))
{
return(mr);
}
var clearComps = new HexKeyThales[_iNbrComponents];
var clearKey = string.Empty;
for (var i = 1; i <= _iNbrComponents; i++)
{
clearComps[i - 1] = new HexKeyThales(ktc, false, _comps[i - 1]);
if (!clearComps[i - 1].ClearKey.IsParityOk(Parity.Odd))
{
mr.Append(ErrorCodes.ER_10_SOURCE_KEY_PARITY_ERROR);
return(mr);
}
clearKey = !string.IsNullOrEmpty(clearKey) ? clearKey.XorHex(clearComps[i - 1].ClearKey) : clearComps[i - 1].ClearKey;
}
clearKey = clearKey.MakeParity(Parity.Odd);
var cryptKey = new HexKeyThales(ktc, true, clearKey);
for (var i = 1; i <= _iNbrComponents; i++)
{
Log.InfoFormat("Component {0} (clear): {1}", i, clearComps[i - 1].ClearKey);
}
Log.InfoFormat("Key (clear): {0}", clearKey);
Log.InfoFormat("Check value: {0}", cryptKey.CheckValue);
mr.Append(ErrorCodes.ER_00_NO_ERROR);
if (lmkKs == KeyScheme.DoubleLengthKeyVariant || lmkKs == KeyScheme.TripleLengthKeyVariant)
{
mr.Append(cryptKey.KeyVariant);
}
else
{
mr.Append(cryptKey.KeyAnsi);
}
mr.Append(cryptKey.CheckValue.Substring(0, 6));
return(mr);
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
KeyTypeCode ktc = null;
if (!ValidateKeyTypeCode(_keyType, mr, ref ktc))
{
return(mr);
}
var zmkKs = KeyScheme.Unspecified;
if (!ValidateKeySchemeCode(_zmkScheme, mr, ref zmkKs))
{
return(mr);
}
if (!ValidateAuthStateRequirement(KeyFunction.Export, ktc.Pair, ktc.Variant, mr))
{
return(mr);
}
var zmk = new HexKeyThales(new KeyTypeCode(0, LmkPair.Pair04_05), false, _zmk);
if (!zmk.ClearKey.IsParityOk(Parity.Odd))
{
mr.Append(ErrorCodes.ER_10_SOURCE_KEY_PARITY_ERROR);
return(mr);
}
var key = new HexKeyThales(ktc, false, _key);
if (!key.ClearKey.IsParityOk(Parity.Odd))
{
mr.Append(ErrorCodes.ER_11_DESTINATION_KEY_PARITY_ERROR);
return(mr);
}
var cryptKey = zmk.EncryptWithScheme(zmkKs.GetKeySchemeChar() + key.ClearKey);
Log.InfoFormat("ZMK (clear): {0}", zmk.ClearKey);
Log.InfoFormat("Key (clear): {0}", key.ClearKey);
Log.InfoFormat("Key (ZMK): {0}", cryptKey);
Log.InfoFormat("Check value: {0}", key.CheckValue);
mr.Append(ErrorCodes.ER_00_NO_ERROR);
mr.Append(zmkKs != KeyScheme.Unspecified && zmkKs != KeyScheme.SingleLengthKey
? zmkKs.GetKeySchemeChar()
: string.Empty);
mr.Append(cryptKey);
mr.Append(key.CheckValue.Substring(0, 6));
return(mr);
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
KeyTypeCode ktc = null;
if (!ValidateKeyTypeCode(_keyType, mr, ref ktc))
{
return(mr);
}
var lmk = KeyScheme.Unspecified;
if (!ValidateKeySchemeCode(_lmkScheme, mr, ref lmk))
{
return(mr);
}
if (!ValidateAuthStateRequirement(KeyFunction.Import, ktc.Pair, ktc.Variant, mr))
{
return(mr);
}
var zmk = new HexKeyThales(new KeyTypeCode(0, LmkPair.Pair04_05), false, _zmk);
if (!zmk.ClearKey.IsParityOk(Parity.Odd))
{
mr.Append(ErrorCodes.ER_10_SOURCE_KEY_PARITY_ERROR);
return(mr);
}
var clearKey = zmk.DecryptWithScheme(_key, _atallaVariant);
var warnParity = !clearKey.IsParityOk(Parity.Odd);
var newKey = new HexKeyThales(ktc, true, clearKey);
var checkValue = newKey.CheckValue;
Log.InfoFormat("ZMK (clear): {0}", zmk.ClearKey);
Log.InfoFormat("Key (clear): {0}", clearKey);
Log.InfoFormat("Key (LMK): {0}", newKey.Key);
Log.InfoFormat("Check value: {0}", checkValue);
if (warnParity)
{
Log.WarnFormat("Key {0} does not have odd parity (would be {1})", clearKey, clearKey.MakeParity(Parity.Odd));
}
mr.Append(ErrorCodes.ER_00_NO_ERROR);
mr.Append(lmk == KeyScheme.DoubleLengthKeyVariant || lmk == KeyScheme.TripleLengthKeyVariant
? newKey.KeyVariant
: newKey.KeyAnsi);
mr.Append(newKey.CheckValue.Substring(0, 6));
return(mr);
}
/// <summary>
/// Parses and validates a key type code.
/// </summary>
/// <param name="keyTypeCode">Key type code to parse.</param>
/// <param name="mr">Message response to add error code to, if parsing fails.</param>
/// <param name="code">Parsed key type code.</param>
/// <returns>True if parsing is successful.</returns>
protected bool ValidateKeyTypeCode(string keyTypeCode, StreamResponse mr, ref KeyTypeCode code)
{
try
{
code = new KeyTypeCode(keyTypeCode);
return(true);
}
catch (InvalidCastException)
{
mr.Append(ErrorCodes.ER_04_INVALID_KEY_TYPE_CODE);
return(false);
}
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
KeyTypeCode ktc = null;
if (!ValidateKeyTypeCode(_keyType, mr, ref ktc))
{
return(mr);
}
var ks = KeyScheme.Unspecified;
if (!ValidateKeySchemeCode(_keyScheme, mr, ref ks))
{
return(mr);
}
var rndKey = string.Empty.RandomKey(ks, Parity.Odd);
var cryptKey = new HexKeyThales(ktc, true, rndKey);
Log.InfoFormat("Key generated (clear): {0}", rndKey);
Log.InfoFormat("Key generated (ANSI): {0}", cryptKey.KeyAnsi);
Log.InfoFormat("Key generated (Variant): {0}", cryptKey.KeyVariant);
AddPrinterData("CLEAR COMPONENT");
AddPrinterData(rndKey);
mr.Append(ErrorCodes.ER_00_NO_ERROR);
mr.Append(ks == KeyScheme.DoubleLengthKeyVariant || ks == KeyScheme.TripleLengthKeyVariant
? cryptKey.KeyVariant
: cryptKey.KeyAnsi);
_result = "OK";
return(mr);
}
/// <summary>
/// Process request.
/// </summary>
/// <returns>Response message.</returns>
public override StreamResponse ConstructResponse()
{
var mr = new StreamResponse();
KeyTypeCode ktc = null;
if (!ValidateKeyTypeCode(_keyType, mr, ref ktc))
{
return(mr);
}
var ks = KeyScheme.Unspecified;
if (!ValidateKeySchemeCode(_keyScheme, mr, ref ks))
{
return(mr);
}
var zmkKs = KeyScheme.Unspecified;
if (!string.IsNullOrEmpty(_zmkScheme))
{
if (!ValidateKeySchemeCode(_zmkScheme, mr, ref zmkKs))
{
return(mr);
}
}
if (!ValidateAuthStateRequirement(KeyFunction.Generate, ktc.Pair, ktc.Variant, mr))
{
return(mr);
}
var rndKey = string.Empty.RandomKey(ks);
var thalesRndKey = new HexKeyThales(ktc, true, rndKey);
Log.InfoFormat("Key generated (clear): {0}", rndKey);
Log.InfoFormat("Key generated (LMK, ANSI): {0}", thalesRndKey.KeyAnsi);
Log.InfoFormat("Key generated (LMK, Variant): {0}", thalesRndKey.KeyVariant);
Log.InfoFormat("Check value: {0}", thalesRndKey.CheckValue);
mr.Append(ErrorCodes.ER_00_NO_ERROR);
mr.Append(ks == KeyScheme.DoubleLengthKeyAnsi || ks == KeyScheme.TripleLengthKeyAnsi
? thalesRndKey.KeyAnsi
: thalesRndKey.KeyVariant);
if (!string.IsNullOrEmpty(_zmk) && _modeFlag == "1")
{
var zmk = new HexKeyThales(new KeyTypeCode(0, LmkPair.Pair04_05), false, _zmk);
if (!zmk.ClearKey.IsParityOk(Parity.Odd))
{
mr.Append(ErrorCodes.ER_10_SOURCE_KEY_PARITY_ERROR);
return(mr);
}
var cryptUnderZmk = zmk.EncryptWithScheme(zmkKs.GetKeySchemeChar() + rndKey);
Log.InfoFormat("ZMK (clear): {0}", zmk.ClearKey);
Log.InfoFormat("Key under ZMK: {0}", zmkKs.GetKeySchemeChar() + cryptUnderZmk);
mr.Append(zmkKs.GetKeySchemeChar() + cryptUnderZmk);
}
mr.Append(thalesRndKey.CheckValue.Substring(0, 6));
return(mr);
}
