public static string CalculateSecurePinVersion9(string pin, byte[] pinKey, string cvv2 = "000", string expiryDate = "0000")
{
if (pinKey == null)
{
throw new ArgumentNullException("pinKey");
}
var pinBlockString = pin + cvv2 + expiryDate;
var clearPinBlock = "2" + pinBlockString.Length + pinBlockString;
const byte randomBytes = 0x0;
var randomDigit = (int)((randomBytes * 10) / 128);
randomDigit = Math.Abs(randomDigit);
var pinPadLength = 16 - clearPinBlock.Length;
for (var i = 0; i < pinPadLength; i++)
{
clearPinBlock += randomDigit;
}
var desEdeEngine = new DesEdeEngine();
var keyParameters = new DesEdeParameters(pinKey);
desEdeEngine.Init(true, keyParameters);
var clearPinBlockBytes = Hex.Decode(clearPinBlock);
var encryptedPinBlockBytes = new byte[8];
desEdeEngine.ProcessBlock(clearPinBlockBytes, 0, encryptedPinBlockBytes, 0);
var encodedEncryptedPinBlockBytes = Hex.Encode(encryptedPinBlockBytes);
var securePin = Encoding.UTF8.GetString(encodedEncryptedPinBlockBytes, 0, encodedEncryptedPinBlockBytes.Length);
return(securePin);
}
public static byte[] generateKey()
{
RandomNumberGenerator rng = RNGCryptoServiceProvider.Create();
SecureRandom sr = new SecureRandom();
KeyGenerationParameters kgp = new KeyGenerationParameters(sr, DesEdeParameters.DesEdeKeyLength * 8);
DesEdeKeyGenerator kg = new DesEdeKeyGenerator();
byte[] key = new byte[16];
kg.Init(kgp);
var keyTmp = kg.GenerateKey();
int len = key.Length;
DesEdeParameters.SetOddParity(keyTmp);
/*
* sbyte[] signedkey = new sbyte[key.Length];
* int i = 0;
* foreach (byte b in key)
* {
* signedkey[i++] = unchecked((sbyte)b);
* }
*/
Array.Copy(keyTmp, 0, key, 0, 16);
return(key);
}
} //protected bool Initialized
protected bool InitializeDESedeKey()
{
_DesEdeParameters = new DesEdeParameters(Hex.Decode(_KeyValue));
_DesEdeEngine = new DesEdeEngine();
_DesEdeEngine.Init(true, _DesEdeParameters);
theKey = _DesEdeParameters.GetKey();
return(false);
}
protected override byte[] engineGenerateKey()
{
byte[] array;
do
{
array = this.random.GenerateSeed(this.strength);
DesParameters.SetOddParity(array);
}while (DesEdeParameters.IsWeakKey(array, 0, array.Length));
return(array);
}
protected override byte[] engineGenerateKey()
{
byte[] array = new byte[strength];
do
{
random.NextBytes(array);
DesParameters.SetOddParity(array);
}while (DesEdeParameters.IsWeakKey(array, 0, array.Length) || !DesEdeParameters.IsRealEdeKey(array, 0));
return(array);
}
private void wrapTest(
string alg,
int id,
byte[] kek,
byte[] iv,
byte[] input,
byte[] output)
{
try
{
IWrapper wrapper = WrapperUtilities.GetWrapper(alg + "Wrap");
KeyParameter desEdeKey = new DesEdeParameters(kek);
wrapper.Init(true, new ParametersWithIV(desEdeKey, iv));
try
{
// byte[] cText = wrapper.Wrap(new SecretKeySpec(input, alg));
byte[] cText = wrapper.Wrap(input, 0, input.Length);
if (!Arrays.AreEqual(cText, output))
{
Fail("failed wrap test " + id + " expected "
+ Hex.ToHexString(output) + " got " + Hex.ToHexString(cText));
}
}
catch (Exception e)
{
Fail("failed wrap test exception " + e.ToString());
}
wrapper.Init(false, desEdeKey);
try
{
// Key pText = wrapper.unwrap(output, alg, IBufferedCipher.SECRET_KEY);
byte[] pText = wrapper.Unwrap(output, 0, output.Length);
// if (!Arrays.AreEqual(pText.getEncoded(), input))
if (!Arrays.AreEqual(pText, input))
{
Fail("failed unwrap test " + id + " expected "
+ Hex.ToHexString(input) + " got "
+ Hex.ToHexString(pText));
}
}
catch (Exception e)
{
Fail("failed unwrap test exception " + e.ToString());
}
}
catch (Exception ex)
{
Fail("failed exception " + ex.ToString());
}
}
public void DecryptKey_TripleDESWrongKeySize()
{
var random = new SecureRandom();
var keydata = new byte[192 / 8];
random.NextBytes(keydata);
var param = new DesEdeParameters(keydata);
byte[] key = Encoding.ASCII.GetBytes("123");
Assert.Throws <System.Security.Cryptography.CryptographicException>(() => EncryptedXml.DecryptKey(key, param));
}
protected override byte[] engineGenerateKey()
{
byte[] newKey;
do
{
newKey = random.GenerateSeed(strength);
DesEdeParameters.SetOddParity(newKey);
}while (DesEdeParameters.IsWeakKey(newKey, 0, newKey.Length));
return(newKey);
}
protected override byte[] engineGenerateKey()
{
byte[] newKey = new byte[strength];
do
{
random.NextBytes(newKey);
DesEdeParameters.SetOddParity(newKey);
}while (DesEdeParameters.IsWeakKey(newKey, 0, newKey.Length));
return(newKey);
}
private static void ValidateKeyUse(Algorithm keyAlg, byte[] keyBytes, Algorithm usageAlg, bool forReading)
{
// FSM_STATE:5.11,"TDES KEY VALIDITY TEST", "The module is validating the size and purpose of an TDES key"
// FSM_TRANS:5.TDES.0,"CONDITIONAL TEST", "TDES KEY VALIDITY TEST", "Invoke Validity test on TDES key"
int keyLength = keyBytes.Length * 8;
if (!forReading) // decryption using 2 key TDES okay,
{
if (CryptoServicesRegistrar.IsInApprovedOnlyMode())
{
if (keyLength == 128)
{
// FSM_TRANS:5.TDES.2,"TDES KEY VALIDITY TEST", "USER COMMAND REJECTED", "Validity test on TDES key failed"
throw new IllegalKeyException("key must be of length 192 bits: " + usageAlg.Name);
}
if (!DesEdeParameters.IsReal3Key(keyBytes))
{
// FSM_TRANS:5.TDES.2,"TDES KEY VALIDITY TEST", "USER COMMAND REJECTED", "Validity test on TDES key failed"
throw new IllegalKeyException("key not real 3-Key TripleDES key");
}
}
}
if (!Properties.IsOverrideSet("Org.BouncyCastle.TripleDes.AllowWeak"))
{
if (!forReading)
{
if (!DesEdeParameters.IsRealEdeKey(keyBytes))
{
// FSM_TRANS:5.TDES.2,"TDES KEY VALIDITY TEST", "USER COMMAND REJECTED", "Validity test on TDES key failed"
throw new IllegalKeyException("attempt to use repeated DES key: " + usageAlg.Name);
}
if (DesEdeParameters.IsWeakKey(keyBytes, 0, keyBytes.Length))
{
// FSM_TRANS:5.TDES.2,"TDES KEY VALIDITY TEST", "USER COMMAND REJECTED", "Validity test on TDES key failed"
throw new IllegalKeyException("attempt to use weak key: " + usageAlg.Name);
}
}
}
if (keyAlg != Alg && keyAlg != Alg112 && keyAlg != Alg168)
{
if (keyAlg != usageAlg)
{
// FSM_TRANS:5.TDES.2,"TDES KEY VALIDITY TEST", "USER COMMAND REJECTED", "Validity test on TDES key failed"
throw new IllegalKeyException("FIPS key not for specified algorithm");
}
}
// FSM_TRANS:5.TDES.0,"TDES KEY VALIDITY TEST", "CONDITIONAL TEST", "Validity test on TDES key successful"
}
public void Init(bool forEncryption, ICipherParameters parameters)
{
byte[] k = Arrays.Clone(((KeyParameter)parameters).GetKey());
DesEdeParameters.SetOddParity(k);
if (!Arrays.AreEqual(((KeyParameter)parameters).GetKey(), k))
{
throw new ArgumentException("key not odd parity");
}
cipher.Init(forEncryption, parameters);
}
public static byte[] GenerateKey()
{
var secureRandom = new SecureRandom();
var kgp = new KeyGenerationParameters(secureRandom, DesEdeParameters.DesKeyLength * 16);
var kg = new DesEdeKeyGenerator();
kg.Init(kgp);
byte[] desKeyBytes = kg.GenerateKey();
DesEdeParameters.SetOddParity(desKeyBytes);
return(desKeyBytes);
}
public static byte[] generateKey()
{
RandomNumberGenerator rng = RNGCryptoServiceProvider.Create();
SecureRandom sr = new SecureRandom();
KeyGenerationParameters kgp = new KeyGenerationParameters(sr, DesEdeParameters.DesEdeKeyLength * 8);
DesEdeKeyGenerator kg = new DesEdeKeyGenerator();
kg.Init(kgp);
var key = kg.GenerateKey();
int len = key.Length;
DesEdeParameters.SetOddParity(key);
return(key);
}
public void EncryptKey_TripleDES()
{
var random = new SecureRandom();
var keydata = new byte[192 / 8];
random.NextBytes(keydata);
var param = new DesEdeParameters(keydata);
byte[] key = Encoding.ASCII.GetBytes("123456781234567812345678");
byte[] encryptedKey = EncryptedXml.EncryptKey(key, param);
Assert.NotNull(encryptedKey);
Assert.Equal(key, EncryptedXml.DecryptKey(encryptedKey, param));
}
public void DecryptKey_TripleDESCorruptedKey()
{
var random = new SecureRandom();
var keydata = new byte[192 / 8];
random.NextBytes(keydata);
var param = new DesEdeParameters(keydata);
byte[] key = Encoding.ASCII.GetBytes("123456781234567812345678");
byte[] encryptedKey = EncryptedXml.EncryptKey(key, param);
encryptedKey[0] ^= 0xFF;
Assert.Throws <System.Security.Cryptography.CryptographicException>(() => EncryptedXml.DecryptKey(encryptedKey, param));
}
public static byte[] BouncyCastleGetCbcMac(string data, byte[] macKey)
{
var macBytes = new byte[4];
var macCipher = new CbcBlockCipherMac(new DesEdeEngine());
var keyParameters = new DesEdeParameters(macKey);
//var engine = new DesEdeEngine();
//engine.Init(true, keyParameters);
macCipher.Init(keyParameters);
var dataBytes = Encoding.UTF8.GetBytes(data);
macCipher.BlockUpdate(dataBytes, 0, data.Length);
macCipher.DoFinal(macBytes, 0);
return(macBytes);
}
public static byte[] decrypt(String encryptedPINBlock, byte[] pinKey)
{
DesEdeEngine engine = new DesEdeEngine();
DesEdeParameters keyParameters = new DesEdeParameters(pinKey);
engine.Init(false, keyParameters);
byte[] encryptedPINBlockBytes = Hex.Encode(Encoding.UTF8.GetBytes(encryptedPINBlock));
byte[] clearPINBlockBytes = new byte[8];
int res = engine.ProcessBlock(encryptedPINBlockBytes, 0, clearPINBlockBytes, 0);
byte[] decodedClearPINBlockBytes = Hex.Decode(clearPINBlockBytes);
AppUtils.zeroise(encryptedPINBlockBytes);
AppUtils.zeroise(clearPINBlockBytes);
return(decodedClearPINBlockBytes);
}
public static byte[] encrypt(string clearPINBlock, byte[] pinKey)
{
DesEdeEngine engine = new DesEdeEngine();
DesEdeParameters keyParameters = new DesEdeParameters(pinKey);
engine.Init(true, keyParameters);
byte[] clearPINBlockBytes = Hex.Decode(clearPINBlock);
byte[] encryptedPINBlockBytes = new byte[8];
int res = engine.ProcessBlock(clearPINBlockBytes, 0, encryptedPINBlockBytes, 0);
byte[] encodedEncryptedPINBlock = Hex.Encode(encryptedPINBlockBytes);
AppUtils.zeroise(clearPINBlockBytes);
AppUtils.zeroise(encryptedPINBlockBytes);
return(encodedEncryptedPINBlock);
}
public static String getMacValue(String macCipherText, byte[] macKey)
{
byte[] macBytes = new byte[4];
CbcBlockCipherMac cipher = new CbcBlockCipherMac(new DesEdeEngine());
DesEdeParameters keyParameters = new DesEdeParameters(macKey);
DesEdeEngine engine = new DesEdeEngine();
engine.Init(true, keyParameters);
cipher.Init(keyParameters);
byte[] macDataBytes = Encoding.UTF8.GetBytes(macCipherText);
cipher.BlockUpdate(macDataBytes, 0, macCipherText.Length);
cipher.DoFinal(macBytes, 0);
byte[] encodedMacBytes = Hex.Encode(macBytes);
String mac = Encoding.Default.GetString(encodedMacBytes);
return(mac);
}
static string DecryptString(string Message, string Passphrase)
{
byte[] Results;
var md = new Sha1Digest();
byte[] TDESKey = new byte[32];
var data = Encoding.UTF8.GetBytes(Passphrase);
md.BlockUpdate(data, 0, data.Length);
md.DoFinal(TDESKey, 0);
Array.Resize(ref TDESKey, 16);
var cp = CipherUtilities.GetCipher("DESede/ECB/PKCS7Padding");
var keySpec = new DesEdeParameters(TDESKey);
cp.Init(false, keySpec);
Results = cp.DoFinal(Convert.FromBase64String(Message));
return(Encoding.UTF8.GetString(Results, 0, Results.Length));
}
public byte[] generateKey()
{
byte[] newKey = new byte[strength];
int count = 0;
do
{
random.NextBytes(newKey);
DesParameters.SetOddParity(newKey);
}while (DesEdeParameters.IsWeakKey(newKey, 0, newKey.Length) && !DesEdeParameters.IsRealEdeKey(newKey) && count++ < 10);
if (DesEdeParameters.IsWeakKey(newKey, 0, newKey.Length) || !DesEdeParameters.IsRealEdeKey(newKey))
{
// if this happens there's got to be something terribly wrong.
throw new CryptoOperationError("Failed to generate a valid TripleDES key: " + algorithm.Name);
}
return(newKey);
}
// default behaviour is to look for keys defined by an EncryptedKey clause
// either directly or through a KeyInfoRetrievalMethod, and key names in the key mapping
public virtual ICipherParameters GetDecryptionKey(EncryptedData encryptedData, string symmetricAlgorithmUri)
{
if (encryptedData == null)
{
throw new ArgumentNullException(nameof(encryptedData));
}
if (encryptedData.KeyInfo == null)
{
return(null);
}
IEnumerator keyInfoEnum = encryptedData.KeyInfo.GetEnumerator();
KeyInfoRetrievalMethod kiRetrievalMethod;
KeyInfoName kiName;
KeyInfoEncryptedKey kiEncKey;
EncryptedKey ek = null;
while (keyInfoEnum.MoveNext())
{
kiName = keyInfoEnum.Current as KeyInfoName;
if (kiName != null)
{
// Get the decryption key from the key mapping
string keyName = kiName.Value;
if (_keyNameMapping[keyName] as ICipherParameters != null)
{
return((ICipherParameters)_keyNameMapping[keyName]);
}
// try to get it from a CarriedKeyName
XmlNamespaceManager nsm = new XmlNamespaceManager(_document.NameTable);
nsm.AddNamespace("enc", EncryptedXml.XmlEncNamespaceUrl);
XmlNodeList encryptedKeyList = _document.SelectNodes("//enc:EncryptedKey", nsm);
if (encryptedKeyList != null)
{
foreach (XmlNode encryptedKeyNode in encryptedKeyList)
{
XmlElement encryptedKeyElement = encryptedKeyNode as XmlElement;
EncryptedKey ek1 = new EncryptedKey();
ek1.LoadXml(encryptedKeyElement);
if (ek1.CarriedKeyName == keyName && ek1.Recipient == Recipient)
{
ek = ek1;
break;
}
}
}
break;
}
kiRetrievalMethod = keyInfoEnum.Current as KeyInfoRetrievalMethod;
if (kiRetrievalMethod != null)
{
string idref = Utils.ExtractIdFromLocalUri(kiRetrievalMethod.Uri);
ek = new EncryptedKey();
ek.LoadXml(GetIdElement(_document, idref));
break;
}
kiEncKey = keyInfoEnum.Current as KeyInfoEncryptedKey;
if (kiEncKey != null)
{
ek = kiEncKey.EncryptedKey;
break;
}
}
// if we have an EncryptedKey, decrypt to get the symmetric key
if (ek != null)
{
// now process the EncryptedKey, loop recursively
// If the Uri is not provided by the application, try to get it from the EncryptionMethod
if (symmetricAlgorithmUri == null)
{
if (encryptedData.EncryptionMethod == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_MissingAlgorithm);
}
symmetricAlgorithmUri = encryptedData.EncryptionMethod.KeyAlgorithm;
}
byte[] key = DecryptEncryptedKey(ek);
if (key == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_MissingDecryptionKey);
}
IBufferedCipher symAlg = CryptoHelpers.CreateFromName <IBufferedCipher>(symmetricAlgorithmUri);
if (symAlg == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_MissingAlgorithm);
}
KeyParameter keyParam;
if (symAlg.AlgorithmName.IndexOf("DESede", StringComparison.OrdinalIgnoreCase) >= 0)
{
keyParam = new DesEdeParameters(key);
}
else if (symAlg.AlgorithmName.IndexOf("DES", StringComparison.OrdinalIgnoreCase) >= 0)
{
keyParam = new DesParameters(key);
}
else
{
keyParam = new KeyParameter(key);
}
return(keyParam);
}
return(null);
}
public override void PerformTest()
{
base.PerformTest();
byte[] kek1 = Hex.Decode("255e0d1c07b646dfb3134cc843ba8aa71f025b7c0838251f");
byte[] iv1 = Hex.Decode("5dd4cbfc96f5453b");
byte[] in1 = Hex.Decode("2923bf85e06dd6ae529149f1f1bae9eab3a7da3d860d3e98");
byte[] out1 = Hex.Decode("690107618ef092b3b48ca1796b234ae9fa33ebb4159604037db5d6a84eb3aac2768c632775a467d4");
WrapTest(1, kek1, iv1, in1, out1);
//
// key generation
//
SecureRandom random = new SecureRandom();
DesEdeKeyGenerator keyGen = new DesEdeKeyGenerator();
keyGen.Init(new KeyGenerationParameters(random, 112));
byte[] kB = keyGen.GenerateKey();
if (kB.Length != 16)
{
Fail("112 bit key wrong length.");
}
keyGen.Init(new KeyGenerationParameters(random, 168));
kB = keyGen.GenerateKey();
if (kB.Length != 24)
{
Fail("168 bit key wrong length.");
}
try
{
keyGen.Init(new KeyGenerationParameters(random, 200));
Fail("invalid key length not detected.");
}
catch (ArgumentException)
{
// expected
}
try
{
DesEdeParameters.IsWeakKey(new byte[4], 0);
Fail("no exception on small key");
}
catch (ArgumentException e)
{
if (!e.Message.Equals("key material too short."))
{
Fail("wrong exception");
}
}
try
{
new DesEdeParameters(weakKey);
Fail("no exception on weak key");
}
catch (ArgumentException e)
{
if (!e.Message.Equals("attempt to create weak DESede key"))
{
Fail("wrong exception");
}
}
}
public override void PerformTest()
{
KeyParameter key = new DesParameters(keyBytes);
IMac mac = MacUtilities.GetMac("DESMac");
//
// standard DAC - zero IV
//
mac.Init(key);
mac.BlockUpdate(input, 0, input.Length);
//byte[] outBytes = mac.DoFinal();
byte[] outBytes = new byte[mac.GetMacSize()];
mac.DoFinal(outBytes, 0);
if (!AreEqual(outBytes, output1))
{
Fail("Failed - expected "
+ Hex.ToHexString(output1) + " got "
+ Hex.ToHexString(outBytes));
}
//
// mac with IV.
//
mac.Init(new ParametersWithIV(key, ivBytes));
mac.BlockUpdate(input, 0, input.Length);
//outBytes = mac.DoFinal();
outBytes = new byte[mac.GetMacSize()];
mac.DoFinal(outBytes, 0);
if (!AreEqual(outBytes, output2))
{
Fail("Failed - expected "
+ Hex.ToHexString(output2) + " got "
+ Hex.ToHexString(outBytes));
}
//
// CFB mac with IV - 8 bit CFB mode
//
mac = MacUtilities.GetMac("DESMac/CFB8");
mac.Init(new ParametersWithIV(key, ivBytes));
mac.BlockUpdate(input, 0, input.Length);
//outBytes = mac.DoFinal();
outBytes = new byte[mac.GetMacSize()];
mac.DoFinal(outBytes, 0);
if (!AreEqual(outBytes, output3))
{
Fail("Failed - expected "
+ Hex.ToHexString(output3) + " got "
+ Hex.ToHexString(outBytes));
}
//
// ISO9797 algorithm 3 using DESEDE
//
key = new DesEdeParameters(keyBytesISO9797);
mac = MacUtilities.GetMac("ISO9797ALG3");
mac.Init(key);
mac.BlockUpdate(inputISO9797, 0, inputISO9797.Length);
//outBytes = mac.DoFinal();
outBytes = new byte[mac.GetMacSize()];
mac.DoFinal(outBytes, 0);
if (!AreEqual(outBytes, outputISO9797))
{
Fail("Failed - expected "
+ Hex.ToHexString(outputISO9797) + " got "
+ Hex.ToHexString(outBytes));
}
//
// 64bit DESede Mac
//
key = new DesEdeParameters(keyBytesISO9797);
mac = MacUtilities.GetMac("DESEDE64");
mac.Init(key);
mac.BlockUpdate(inputDesEDE64, 0, inputDesEDE64.Length);
//outBytes = mac.DoFinal();
outBytes = new byte[mac.GetMacSize()];
mac.DoFinal(outBytes, 0);
if (!AreEqual(outBytes, outputDesEDE64))
{
Fail("Failed - expected "
+ Hex.ToHexString(outputDesEDE64) + " got "
+ Hex.ToHexString(outBytes));
}
aliasTest(
ParameterUtilities.CreateKeyParameter("DESede", keyBytesISO9797),
"DESedeMac64withISO7816-4Padding",
"DESEDE64WITHISO7816-4PADDING",
"DESEDEISO9797ALG1MACWITHISO7816-4PADDING",
"DESEDEISO9797ALG1WITHISO7816-4PADDING");
aliasTest(
ParameterUtilities.CreateKeyParameter("DESede", keyBytesISO9797),
"ISO9797ALG3WITHISO7816-4PADDING",
"ISO9797ALG3MACWITHISO7816-4PADDING");
}
private void doTest(
string alg,
int strength,
byte[] input,
byte[] output)
{
KeyParameter key = null;
CipherKeyGenerator keyGen;
SecureRandom rand;
IBufferedCipher inCipher = null;
IBufferedCipher outCipher = null;
CipherStream cIn;
CipherStream cOut;
MemoryStream bIn;
MemoryStream bOut;
rand = new FixedSecureRandom();
try
{
keyGen = GeneratorUtilities.GetKeyGenerator(alg);
keyGen.Init(new KeyGenerationParameters(rand, strength));
key = new DesEdeParameters(keyGen.GenerateKey());
inCipher = CipherUtilities.GetCipher(alg + "/ECB/PKCS7Padding");
outCipher = CipherUtilities.GetCipher(alg + "/ECB/PKCS7Padding");
outCipher.Init(true, new ParametersWithRandom(key, rand));
}
catch (Exception e)
{
Fail(alg + " failed initialisation - " + e.ToString());
}
try
{
inCipher.Init(false, key);
}
catch (Exception e)
{
Fail(alg + " failed initialisation - " + e.ToString());
}
//
// encryption pass
//
bOut = new MemoryStream();
cOut = new CipherStream(bOut, null, outCipher);
try
{
for (int i = 0; i != input.Length / 2; i++)
{
cOut.WriteByte(input[i]);
}
cOut.Write(input, input.Length / 2, input.Length - input.Length / 2);
cOut.Close();
}
catch (IOException e)
{
Fail(alg + " failed encryption - " + e.ToString());
}
byte[] bytes = bOut.ToArray();
if (!Arrays.AreEqual(bytes, output))
{
Fail(alg + " failed encryption - expected "
+ Hex.ToHexString(output) + " got "
+ Hex.ToHexString(bytes));
}
//
// decryption pass
//
bIn = new MemoryStream(bytes, false);
cIn = new CipherStream(bIn, inCipher, null);
try
{
// DataInputStream dIn = new DataInputStream(cIn);
BinaryReader dIn = new BinaryReader(cIn);
bytes = new byte[input.Length];
for (int i = 0; i != input.Length / 2; i++)
{
bytes[i] = (byte)dIn.ReadByte();
}
// dIn.readFully(bytes, input.Length / 2, bytes.Length - input.Length / 2);
int remaining = bytes.Length - input.Length / 2;
byte[] rest = dIn.ReadBytes(remaining);
if (rest.Length != remaining)
{
throw new Exception("IO problem with BinaryReader");
}
rest.CopyTo(bytes, input.Length / 2);
}
catch (Exception e)
{
Fail(alg + " failed encryption - " + e.ToString());
}
if (!Arrays.AreEqual(bytes, input))
{
Fail(alg + " failed decryption - expected "
+ Hex.ToHexString(input) + " got "
+ Hex.ToHexString(bytes));
}
// TODO Put back in
// //
// // keyspec test
// //
// try
// {
// SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(alg);
// DESedeKeySpec keySpec = (DESedeKeySpec)keyFactory.getKeySpec((SecretKey)key, DESedeKeySpec.class);
//
// if (!equalArray(key.getEncoded(), keySpec.getKey(), 16))
// {
// Fail(alg + " KeySpec does not match key.");
// }
// }
// catch (Exception e)
// {
// Fail(alg + " failed keyspec - " + e.ToString());
// }
}
