diff --git a/crypto/test/src/test/AESTest.cs b/crypto/test/src/test/AESTest.cs
index a0545239e..932f959b3 100644
--- a/crypto/test/src/test/AESTest.cs
+++ b/crypto/test/src/test/AESTest.cs
@@ -1,6 +1,5 @@
using System;
using System.IO;
-using System.Text;
using NUnit.Framework;
@@ -10,6 +9,7 @@ using Org.BouncyCastle.Crypto.IO;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
namespace Org.BouncyCastle.Tests
{
@@ -44,7 +44,7 @@ namespace Org.BouncyCastle.Tests
{
for (int i = 0; i != cipherTests.Length; i += 4)
{
- doCipherTest(int.Parse(cipherTests[i]),
+ DoCipherTest(int.Parse(cipherTests[i]),
Hex.Decode(cipherTests[i + 1]),
Hex.Decode(cipherTests[i + 2]),
Hex.Decode(cipherTests[i + 3]));
@@ -97,7 +97,27 @@ namespace Org.BouncyCastle.Tests
wrapTest(1, "AESWrap", kek1, in1, out1);
}
- [Test]
+ [Test]
+ public void TestWrapRfc3211()
+ {
+ byte[] kek2 = Hex.Decode("000102030405060708090a0b0c0d0e0f");
+ byte[] in2 = Hex.Decode("00112233445566778899aabbccddeeff");
+ byte[] out2 = Hex.Decode("7c8798dfc802553b3f00bb4315e3a087322725c92398b9c112c74d0925c63b61");
+
+ wrapTest(2, "AESRFC3211WRAP", kek2, kek2, FixedSecureRandom.From(Hex.Decode("9688df2af1b7b1ac9688df2a")), in2, out2);
+ }
+
+ [Test]
+ public void TestWrapRfc5649()
+ {
+ byte[] kek3 = Hex.Decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
+ byte[] in3 = Hex.Decode("c37b7e6492584340bed12207808941155068f738");
+ byte[] out3 = Hex.Decode("138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a");
+
+ wrapTest(3, "AESWrapPad", kek3, in3, out3);
+ }
+
+ [Test]
public void TestWrapOids()
{
string[] wrapOids =
@@ -110,11 +130,20 @@ namespace Org.BouncyCastle.Tests
wrapOidTest(wrapOids, "AESWrap");
}
- private void doCipherTest(
- int strength,
- byte[] keyBytes,
- byte[] input,
- byte[] output)
+ [Test]
+ public void TestWrapPadOids()
+ {
+ string[] wrapPadOids =
+ {
+ NistObjectIdentifiers.IdAes128WrapPad.Id,
+ NistObjectIdentifiers.IdAes192WrapPad.Id,
+ NistObjectIdentifiers.IdAes256WrapPad.Id
+ };
+
+ wrapOidTest(wrapPadOids, "AESWrapPad");
+ }
+
+ private void DoCipherTest(int strength, byte[] keyBytes, byte[] input, byte[] output)
{
KeyParameter key = ParameterUtilities.CreateKeyParameter("AES", keyBytes);
@@ -343,15 +372,60 @@ namespace Org.BouncyCastle.Tests
}
}
+ [Test]
+ public void TestOcb()
+ {
+ byte[] K = Hex.Decode("000102030405060708090A0B0C0D0E0F");
+ byte[] P = Hex.Decode("000102030405060708090A0B0C0D0E0F");
+ byte[] N = Hex.Decode("000102030405060708090A0B");
+ string T = "4CBB3E4BD6B456AF";
+ byte[] C = Hex.Decode("BEA5E8798DBE7110031C144DA0B2612213CC8B747807121A" + T);
+
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("AES", K);
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("AES/OCB/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("AES/OCB/NoPadding");
+
+ inCipher.Init(true, new ParametersWithIV(key, N));
+
+ byte[] enc = inCipher.DoFinal(P);
+ if (!AreEqual(enc, C))
+ {
+ Fail("ciphertext doesn't match in OCB");
+ }
+
+ outCipher.Init(false, new ParametersWithIV(key, N));
+
+ byte[] dec = outCipher.DoFinal(C);
+ if (!AreEqual(dec, P))
+ {
+ Fail("plaintext doesn't match in OCB");
+ }
+
+ try
+ {
+ inCipher = CipherUtilities.GetCipher("AES/OCB/PKCS5Padding");
+
+ Fail("bad padding missed in OCB");
+ }
+ catch (SecurityUtilityException)
+ {
+ // expected
+ }
+ }
+
public override void PerformTest()
{
TestCiphers();
TestWrap();
- TestOids();
+ TestWrapRfc3211();
+ TestWrapRfc5649();
+ TestOids();
TestWrapOids();
- TestEax();
+ TestWrapPadOids();
+ TestEax();
TestCcm();
TestGcm();
- }
- }
+ TestOcb();
+ }
+ }
}
diff --git a/crypto/test/src/test/AriaTest.cs b/crypto/test/src/test/AriaTest.cs
new file mode 100644
index 000000000..3e95ae947
--- /dev/null
+++ b/crypto/test/src/test/AriaTest.cs
@@ -0,0 +1,428 @@
+using System;
+using System.IO;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Nsri;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.IO;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Tests
+{
+ /// <remarks>Basic test class for the ARIA cipher vectors from FIPS-197</remarks>
+ [TestFixture]
+ public class AriaTest
+ : BaseBlockCipherTest
+ {
+ internal static readonly string[] cipherTests =
+ {
+ "128",
+ "000102030405060708090a0b0c0d0e0f",
+ "00112233445566778899aabbccddeeff",
+ "d718fbd6ab644c739da95f3be6451778",
+ "192",
+ "000102030405060708090a0b0c0d0e0f1011121314151617",
+ "00112233445566778899aabbccddeeff",
+ "26449c1805dbe7aa25a468ce263a9e79",
+ "256",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "00112233445566778899aabbccddeeff",
+ "f92bd7c79fb72e2f2b8f80c1972d24fc"
+ };
+
+ public AriaTest()
+ : base("ARIA")
+ {
+ }
+
+ [Test]
+ public void TestCiphers()
+ {
+ for (int i = 0; i != cipherTests.Length; i += 4)
+ {
+ DoCipherTest(int.Parse(cipherTests[i]),
+ Hex.Decode(cipherTests[i + 1]),
+ Hex.Decode(cipherTests[i + 2]),
+ Hex.Decode(cipherTests[i + 3]));
+ }
+ }
+
+ [Test]
+ public void TestOids()
+ {
+ string[] oids = {
+ NsriObjectIdentifiers.id_aria128_ecb.Id,
+ NsriObjectIdentifiers.id_aria128_cbc.Id,
+ NsriObjectIdentifiers.id_aria128_ofb.Id,
+ NsriObjectIdentifiers.id_aria128_cfb.Id,
+ NsriObjectIdentifiers.id_aria192_ecb.Id,
+ NsriObjectIdentifiers.id_aria192_cbc.Id,
+ NsriObjectIdentifiers.id_aria192_ofb.Id,
+ NsriObjectIdentifiers.id_aria192_cfb.Id,
+ NsriObjectIdentifiers.id_aria256_ecb.Id,
+ NsriObjectIdentifiers.id_aria256_cbc.Id,
+ NsriObjectIdentifiers.id_aria256_ofb.Id,
+ NsriObjectIdentifiers.id_aria256_cfb.Id
+ };
+
+ string[] names = {
+ "ARIA/ECB/PKCS7Padding",
+ "ARIA/CBC/PKCS7Padding",
+ "ARIA/OFB/NoPadding",
+ "ARIA/CFB/NoPadding",
+ "ARIA/ECB/PKCS7Padding",
+ "ARIA/CBC/PKCS7Padding",
+ "ARIA/OFB/NoPadding",
+ "ARIA/CFB/NoPadding",
+ "ARIA/ECB/PKCS7Padding",
+ "ARIA/CBC/PKCS7Padding",
+ "ARIA/OFB/NoPadding",
+ "ARIA/CFB/NoPadding"
+ };
+
+ oidTest(oids, names, 4);
+ }
+
+ [Test]
+ public void TestWrap()
+ {
+ byte[] kek1 = Hex.Decode("000102030405060708090a0b0c0d0e0f");
+ byte[] in1 = Hex.Decode("00112233445566778899aabbccddeeff");
+ byte[] out1 = Hex.Decode("a93f148d4909d85f1aae656909879275ae597b3acf9d60db");
+
+ wrapTest(1, "ARIAWrap", kek1, in1, out1);
+ }
+
+ [Test]
+ public void TestWrapRfc3211()
+ {
+ byte[] kek2 = Hex.Decode("000102030405060708090a0b0c0d0e0f");
+ byte[] in2 = Hex.Decode("00112233445566778899aabbccddeeff");
+ byte[] out2 = Hex.Decode("9b2d3cac0acf9d4bde7c1bdb0313fbef931f025acc77bf57d3d1cabc88b514d0");
+
+ wrapTest(2, "ARIARFC3211WRAP", kek2, kek2, FixedSecureRandom.From(Hex.Decode("9688df2af1b7b1ac9688df2a")), in2, out2);
+ }
+
+ [Test]
+ public void TestWrapRfc5649()
+ {
+ byte[] kek3 = Hex.Decode("000102030405060708090a0b0c0d0e0f");
+ byte[] in3 = Hex.Decode("00112233445566778899aabbccddeeff");
+ byte[] out3 = Hex.Decode("ac0e22699a036ced63adeb75f4946f82dc98ad8af43b24d5");
+
+ wrapTest(3, "ARIAWrapPad", kek3, in3, out3);
+ }
+
+ [Test]
+ public void TestWrapOids()
+ {
+ string[] wrapOids =
+ {
+ NsriObjectIdentifiers.id_aria128_kw.Id,
+ NsriObjectIdentifiers.id_aria192_kw.Id,
+ NsriObjectIdentifiers.id_aria256_kw.Id
+ };
+
+ wrapOidTest(wrapOids, "ARIAWrap");
+ }
+
+ [Test]
+ public void TestWrapPadOids()
+ {
+ string[] wrapPadOids =
+ {
+ NsriObjectIdentifiers.id_aria128_kwp.Id,
+ NsriObjectIdentifiers.id_aria192_kwp.Id,
+ NsriObjectIdentifiers.id_aria256_kwp.Id
+ };
+
+ wrapOidTest(wrapPadOids, "ARIAWrapPad");
+ }
+
+ private void DoCipherTest(int strength, byte[] keyBytes, byte[] input, byte[] output)
+ {
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("ARIA", keyBytes);
+
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("ARIA/ECB/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("ARIA/ECB/NoPadding");
+
+ try
+ {
+ outCipher.Init(true, key);
+ }
+ catch (Exception e)
+ {
+ Fail("ARIA failed initialisation - " + e, e);
+ }
+
+ try
+ {
+ inCipher.Init(false, key);
+ }
+ catch (Exception e)
+ {
+ Fail("ARIA failed initialisation - " + e, e);
+ }
+
+ //
+ // encryption pass
+ //
+ MemoryStream bOut = new MemoryStream();
+
+ CipherStream 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("ARIA failed encryption - " + e, e);
+ }
+
+ byte[] bytes = bOut.ToArray();
+
+ if (!AreEqual(bytes, output))
+ {
+ Fail("ARIA failed encryption - expected "
+ + Hex.ToHexString(output) + " got "
+ + Hex.ToHexString(bytes));
+ }
+
+ //
+ // decryption pass
+ //
+ MemoryStream bIn = new MemoryStream(bytes, false);
+
+ CipherStream 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.read();
+ bytes[i] = dIn.ReadByte();
+ }
+
+ int remaining = bytes.Length - input.Length / 2;
+// dIn.readFully(bytes, input.Length / 2, remaining);
+ byte[] extra = dIn.ReadBytes(remaining);
+ if (extra.Length < remaining)
+ throw new EndOfStreamException();
+ extra.CopyTo(bytes, input.Length / 2);
+ }
+ catch (Exception e)
+ {
+ Fail("ARIA failed encryption - " + e, e);
+ }
+
+ if (!AreEqual(bytes, input))
+ {
+ Fail("ARIA failed decryption - expected "
+ + Hex.ToHexString(input) + " got "
+ + Hex.ToHexString(bytes));
+ }
+ }
+
+ [Test]
+ public void TestEax()
+ {
+ byte[] K = Hex.Decode("233952DEE4D5ED5F9B9C6D6FF80FF478");
+ byte[] N = Hex.Decode("62EC67F9C3A4A407FCB2A8C49031A8B3");
+ byte[] P = Hex.Decode("68656c6c6f20776f726c642121");
+ byte[] C = Hex.Decode("85fe63d6cfb872d2420e65425c074dfad6fe752e03");
+
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("ARIA", K);
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("ARIA/EAX/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("ARIA/EAX/NoPadding");
+
+ inCipher.Init(true, new ParametersWithIV(key, N));
+
+ byte[] enc = inCipher.DoFinal(P);
+ if (!AreEqual(enc, C))
+ {
+ Fail("ciphertext doesn't match in EAX");
+ }
+
+ outCipher.Init(false, new ParametersWithIV(key, N));
+
+ byte[] dec = outCipher.DoFinal(C);
+ if (!AreEqual(dec, P))
+ {
+ Fail("plaintext doesn't match in EAX");
+ }
+
+ try
+ {
+ inCipher = CipherUtilities.GetCipher("ARIA/EAX/PKCS5Padding");
+
+ Fail("bad padding missed in EAX");
+ }
+ catch (SecurityUtilityException)
+ {
+ // expected
+ }
+ }
+
+ [Test]
+ public void TestCcm()
+ {
+ byte[] K = Hex.Decode("404142434445464748494a4b4c4d4e4f");
+ byte[] N = Hex.Decode("10111213141516");
+ byte[] P = Hex.Decode("68656c6c6f20776f726c642121");
+ byte[] C = Hex.Decode("0af625ff69cd9dbe65fae181d654717eb7a0263bcd");
+
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("ARIA", K);
+
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("ARIA/CCM/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("ARIA/CCM/NoPadding");
+
+ inCipher.Init(true, new ParametersWithIV(key, N));
+
+ byte[] enc = inCipher.DoFinal(P);
+ if (!AreEqual(enc, C))
+ {
+ Fail("ciphertext doesn't match in CCM");
+ }
+
+ outCipher.Init(false, new ParametersWithIV(key, N));
+
+ byte[] dec = outCipher.DoFinal(C);
+ if (!AreEqual(dec, P))
+ {
+ Fail("plaintext doesn't match in CCM");
+ }
+
+ try
+ {
+ inCipher = CipherUtilities.GetCipher("ARIA/CCM/PKCS5Padding");
+
+ Fail("bad padding missed in CCM");
+ }
+ catch (SecurityUtilityException)
+ {
+ // expected
+ }
+ }
+
+ [Test]
+ public void TestGcm()
+ {
+ // Test Case 15 from McGrew/Viega
+ byte[] K = Hex.Decode(
+ "feffe9928665731c6d6a8f9467308308"
+ + "feffe9928665731c6d6a8f9467308308");
+ byte[] P = Hex.Decode(
+ "d9313225f88406e5a55909c5aff5269a"
+ + "86a7a9531534f7da2e4c303d8a318a72"
+ + "1c3c0c95956809532fcf0e2449a6b525"
+ + "b16aedf5aa0de657ba637b391aafd255");
+ byte[] N = Hex.Decode("cafebabefacedbaddecaf888");
+ string T = "c8f245c8619ca9ba7d6d9545e7f48214";
+ byte[] C = Hex.Decode(
+ "c3aa0e01a4f8b5dfdb25d0f1c78c275e516114080e2be7a7f7bffd4504b19a8552f80ad5b55f3d911725489629996d398d5ed6f077e22924c5b8ebe20a219693"
+ + T);
+
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("ARIA", K);
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("ARIA/GCM/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("ARIA/GCM/NoPadding");
+
+ inCipher.Init(true, new ParametersWithIV(key, N));
+
+ byte[] enc = inCipher.DoFinal(P);
+ if (!AreEqual(enc, C))
+ {
+ Fail("ciphertext doesn't match in GCM");
+ }
+
+ outCipher.Init(false, new ParametersWithIV(key, N));
+
+ byte[] dec = outCipher.DoFinal(C);
+ if (!AreEqual(dec, P))
+ {
+ Fail("plaintext doesn't match in GCM");
+ }
+
+ try
+ {
+ inCipher = CipherUtilities.GetCipher("ARIA/GCM/PKCS5Padding");
+
+ Fail("bad padding missed in GCM");
+ }
+ catch (SecurityUtilityException)
+ {
+ // expected
+ }
+ }
+
+ [Test]
+ public void TestOcb()
+ {
+ byte[] K = Hex.Decode("000102030405060708090A0B0C0D0E0F");
+ byte[] P = Hex.Decode("000102030405060708090A0B0C0D0E0F");
+ byte[] N = Hex.Decode("000102030405060708090A0B");
+ string T = "0027ce4f3aaeec75";
+ byte[] C = Hex.Decode("7bcae9eac9f1f54704a630e309099a87f53a1c1559de1b3b" + T);
+
+ KeyParameter key = ParameterUtilities.CreateKeyParameter("ARIA", K);
+ IBufferedCipher inCipher = CipherUtilities.GetCipher("ARIA/OCB/NoPadding");
+ IBufferedCipher outCipher = CipherUtilities.GetCipher("ARIA/OCB/NoPadding");
+
+ inCipher.Init(true, new ParametersWithIV(key, N));
+
+ byte[] enc = inCipher.DoFinal(P);
+ if (!AreEqual(enc, C))
+ {
+ Fail("ciphertext doesn't match in OCB");
+ }
+
+ outCipher.Init(false, new ParametersWithIV(key, N));
+
+ byte[] dec = outCipher.DoFinal(C);
+ if (!AreEqual(dec, P))
+ {
+ Fail("plaintext doesn't match in OCB");
+ }
+
+ try
+ {
+ inCipher = CipherUtilities.GetCipher("ARIA/OCB/PKCS5Padding");
+
+ Fail("bad padding missed in OCB");
+ }
+ catch (SecurityUtilityException)
+ {
+ // expected
+ }
+ }
+
+ public override void PerformTest()
+ {
+ TestCiphers();
+ TestWrap();
+ TestWrapRfc3211();
+ TestWrapRfc5649();
+ TestOids();
+ TestWrapOids();
+ TestWrapPadOids();
+ TestEax();
+ TestCcm();
+ TestGcm();
+ TestOcb();
+ }
+ }
+}
diff --git a/crypto/test/src/test/BaseBlockCipherTest.cs b/crypto/test/src/test/BaseBlockCipherTest.cs
index 2997126f6..2381d92b0 100644
--- a/crypto/test/src/test/BaseBlockCipherTest.cs
+++ b/crypto/test/src/test/BaseBlockCipherTest.cs
@@ -94,23 +94,30 @@ namespace Org.BouncyCastle.Tests
}
}
- protected void wrapTest(
- int id,
- string wrappingAlgorithm,
- byte[] kek,
- byte[] inBytes,
- byte[] outBytes)
+ protected void wrapTest(int id, string wrappingAlgorithm, byte[] kek, byte[] inBytes, byte[] outBytes)
{
+ wrapTest(id, wrappingAlgorithm, kek, null, null, inBytes, outBytes);
+ }
+
+ protected void wrapTest(int id, string wrappingAlgorithm, byte[] kek, byte[] iv, SecureRandom rand,
+ byte[] inBytes, byte[] outBytes)
+ {
IWrapper wrapper = WrapperUtilities.GetWrapper(wrappingAlgorithm);
- wrapper.Init(true, ParameterUtilities.CreateKeyParameter(algorithm, kek));
+ ICipherParameters cp = ParameterUtilities.CreateKeyParameter(algorithm, kek);
+ if (iv != null)
+ {
+ cp = new ParametersWithIV(cp, iv);
+ }
+
+ wrapper.Init(true, ParameterUtilities.WithRandom(cp, rand));
try
{
byte[] cText = wrapper.Wrap(inBytes, 0, inBytes.Length);
if (!AreEqual(cText, outBytes))
{
- Fail("failed wrap test " + id + " expected "
+ Fail("failed wrap test " + id + " expected "
+ Hex.ToHexString(outBytes) + " got "
+ Hex.ToHexString(cText));
}
@@ -124,7 +131,7 @@ namespace Org.BouncyCastle.Tests
Fail("failed wrap test exception " + e.ToString(), e);
}
- wrapper.Init(false, ParameterUtilities.CreateKeyParameter(algorithm, kek));
+ wrapper.Init(false, cp);
try
{
@@ -132,7 +139,7 @@ namespace Org.BouncyCastle.Tests
if (!AreEqual(pTextBytes, inBytes))
{
- Fail("failed unwrap test " + id + " expected "
+ Fail("failed unwrap test " + id + " expected "
+ Hex.ToHexString(inBytes) + " got "
+ Hex.ToHexString(pTextBytes));
}
|
