RFC 7748: Export size constants for scalars, points

4 files changed, 66 insertions, 42 deletions

diff --git a/crypto/src/math/ec/rfc7748/X25519.cs b/crypto/src/math/ec/rfc7748/X25519.cs
index a10d53da5..d63cc5a3e 100644
--- a/crypto/src/math/ec/rfc7748/X25519.cs
+++ b/crypto/src/math/ec/rfc7748/X25519.cs
@@ -6,6 +6,9 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748
 {
     public abstract class X25519
     {
+        public const int PointSize = 32;
+        public const int ScalarSize = 32;
+
         private const int C_A = 486662;
         private const int C_A24 = (C_A + 2)/4;
 
diff --git a/crypto/src/math/ec/rfc7748/X448.cs b/crypto/src/math/ec/rfc7748/X448.cs
index 88e8a5d76..aac603b08 100644
--- a/crypto/src/math/ec/rfc7748/X448.cs
+++ b/crypto/src/math/ec/rfc7748/X448.cs
@@ -6,6 +6,9 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748
 {
     public abstract class X448
     {
+        public const int PointSize = 56;
+        public const int ScalarSize = 56;
+
         private const uint C_A = 156326;
         private const uint C_A24 = (C_A + 2)/4;
 
diff --git a/crypto/test/src/math/ec/rfc7748/test/X25519Test.cs b/crypto/test/src/math/ec/rfc7748/test/X25519Test.cs
index 89c325fd5..562e0e423 100644
--- a/crypto/test/src/math/ec/rfc7748/test/X25519Test.cs
+++ b/crypto/test/src/math/ec/rfc7748/test/X25519Test.cs
@@ -22,10 +22,10 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         [Test]
         public void TestConsistency()
         {
-            byte[] u = new byte[32];    u[0] = 9;
-            byte[] k = new byte[32];
-            byte[] rF = new byte[32];
-            byte[] rV = new byte[32];
+            byte[] u = new byte[X25519.PointSize];      u[0] = 9;
+            byte[] k = new byte[X25519.ScalarSize];
+            byte[] rF = new byte[X25519.PointSize];
+            byte[] rV = new byte[X25519.PointSize];
 
             for (int i = 1; i <= 100; ++i)
             {
@@ -39,12 +39,12 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         [Test]
         public void TestECDH()
         {
-            byte[] kA = new byte[32];
-            byte[] kB = new byte[32];
-            byte[] qA = new byte[32];
-            byte[] qB = new byte[32];
-            byte[] sA = new byte[32];
-            byte[] sB = new byte[32];
+            byte[] kA = new byte[X25519.ScalarSize];
+            byte[] kB = new byte[X25519.ScalarSize];
+            byte[] qA = new byte[X25519.PointSize];
+            byte[] qB = new byte[X25519.PointSize];
+            byte[] sA = new byte[X25519.PointSize];
+            byte[] sB = new byte[X25519.PointSize];
 
             for (int i = 1; i <= 100; ++i)
             {
@@ -116,38 +116,43 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         private static void CheckECDHVector(string sA, string sAPub, string sB, string sBPub, string sK, string text)
         {
             byte[] a = Hex.Decode(sA);
+            Assert.AreEqual(X25519.ScalarSize, a.Length);
+
             byte[] b = Hex.Decode(sB);
+            Assert.AreEqual(X25519.ScalarSize, b.Length);
 
-            byte[] aPub = new byte[32];
+            byte[] aPub = new byte[X25519.PointSize];
             X25519.ScalarMultBase(a, 0, aPub, 0);
             CheckValue(aPub, text, sAPub);
 
-            byte[] bPub = new byte[32];
+            byte[] bPub = new byte[X25519.PointSize];
             X25519.ScalarMultBase(b, 0, bPub, 0);
             CheckValue(bPub, text, sBPub);
 
-            byte[] aK = new byte[32];
+            byte[] aK = new byte[X25519.PointSize];
             X25519.ScalarMult(a, 0, bPub, 0, aK, 0);
             CheckValue(aK, text, sK);
 
-            byte[] bK = new byte[32];
+            byte[] bK = new byte[X25519.PointSize];
             X25519.ScalarMult(b, 0, aPub, 0, bK, 0);
             CheckValue(bK, text, sK);
         }
 
         private static void CheckIterated(int count)
         {
-            byte[] k = new byte[32]; k[0] = 9;
-            byte[] u = new byte[32]; u[0] = 9;
-            byte[] r = new byte[32];
+            Assert.AreEqual(X25519.PointSize, X25519.ScalarSize);
+
+            byte[] k = new byte[X25519.PointSize];     k[0] = 9;
+            byte[] u = new byte[X25519.PointSize];     u[0] = 9;
+            byte[] r = new byte[X25519.PointSize];
 
             int iterations = 0;
             while (iterations < count)
             {
                 X25519.ScalarMult(k, 0, u, 0, r, 0);
 
-                Array.Copy(k, 0, u, 0, 32);
-                Array.Copy(r, 0, k, 0, 32);
+                Array.Copy(k, 0, u, 0, X25519.PointSize);
+                Array.Copy(r, 0, k, 0, X25519.PointSize);
 
                 switch (++iterations)
                 {
@@ -175,8 +180,12 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         private static void CheckX25519Vector(string sk, string su, string se, string text)
         {
             byte[] k = Hex.Decode(sk);
+            Assert.AreEqual(X25519.ScalarSize, k.Length);
+
             byte[] u = Hex.Decode(su);
-            byte[] r = new byte[32];
+            Assert.AreEqual(X25519.PointSize, u.Length);
+
+            byte[] r = new byte[X25519.PointSize];
             X25519.ScalarMult(k, 0, u, 0, r, 0);
             CheckValue(r, text, se);
         }
diff --git a/crypto/test/src/math/ec/rfc7748/test/X448Test.cs b/crypto/test/src/math/ec/rfc7748/test/X448Test.cs
index b095eade0..df0158b96 100644
--- a/crypto/test/src/math/ec/rfc7748/test/X448Test.cs
+++ b/crypto/test/src/math/ec/rfc7748/test/X448Test.cs
@@ -22,10 +22,10 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         [Test]
         public void TestConsistency()
         {
-            byte[] u = new byte[56];    u[0] = 5;
-            byte[] k = new byte[56];
-            byte[] rF = new byte[56];
-            byte[] rV = new byte[56];
+            byte[] u = new byte[X448.PointSize];       u[0] = 5;
+            byte[] k = new byte[X448.ScalarSize];
+            byte[] rF = new byte[X448.PointSize];
+            byte[] rV = new byte[X448.PointSize];
 
             for (int i = 1; i <= 100; ++i)
             {
@@ -39,12 +39,12 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         [Test]
         public void TestECDH()
         {
-            byte[] kA = new byte[56];
-            byte[] kB = new byte[56];
-            byte[] qA = new byte[56];
-            byte[] qB = new byte[56];
-            byte[] sA = new byte[56];
-            byte[] sB = new byte[56];
+            byte[] kA = new byte[X448.ScalarSize];
+            byte[] kB = new byte[X448.ScalarSize];
+            byte[] qA = new byte[X448.PointSize];
+            byte[] qB = new byte[X448.PointSize];
+            byte[] sA = new byte[X448.PointSize];
+            byte[] sB = new byte[X448.PointSize];
 
             for (int i = 1; i <= 100; ++i)
             {
@@ -112,38 +112,43 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
         private static void CheckECDHVector(string sA, string sAPub, string sB, string sBPub, string sK, string text)
         {
             byte[] a = Hex.Decode(sA);
+            Assert.AreEqual(X448.ScalarSize, a.Length);
+
             byte[] b = Hex.Decode(sB);
+            Assert.AreEqual(X448.ScalarSize, b.Length);
 
-            byte[] aPub = new byte[56];
+            byte[] aPub = new byte[X448.PointSize];
             X448.ScalarMultBase(a, 0, aPub, 0);
             CheckValue(aPub, text, sAPub);
 
-            byte[] bPub = new byte[56];
+            byte[] bPub = new byte[X448.PointSize];
             X448.ScalarMultBase(b, 0, bPub, 0);
             CheckValue(bPub, text, sBPub);
 
-            byte[] aK = new byte[56];
+            byte[] aK = new byte[X448.PointSize];
             X448.ScalarMult(a, 0, bPub, 0, aK, 0);
             CheckValue(aK, text, sK);
 
-            byte[] bK = new byte[56];
+            byte[] bK = new byte[X448.PointSize];
             X448.ScalarMult(b, 0, aPub, 0, bK, 0);
             CheckValue(bK, text, sK);
         }
 
         private static void CheckIterated(int count)
         {
-            byte[] k = new byte[56]; k[0] = 5;
-            byte[] u = new byte[56]; u[0] = 5;
-            byte[] r = new byte[56];
+            Assert.AreEqual(X448.PointSize, X448.ScalarSize);
+
+            byte[] k = new byte[X448.PointSize];    k[0] = 5;
+            byte[] u = new byte[X448.PointSize];    u[0] = 5;
+            byte[] r = new byte[X448.PointSize];
 
             int iterations = 0;
             while (iterations < count)
             {
                 X448.ScalarMult(k, 0, u, 0, r, 0);
 
-                Array.Copy(k, 0, u, 0, 56);
-                Array.Copy(r, 0, k, 0, 56);
+                Array.Copy(k, 0, u, 0, X448.PointSize);
+                Array.Copy(r, 0, k, 0, X448.PointSize);
 
                 switch (++iterations)
                 {
@@ -165,17 +170,21 @@ namespace Org.BouncyCastle.Math.EC.Rfc7748.Tests
             }
         }
 
-        private static void CheckValue(byte[] n, String text, String se)
+        private static void CheckValue(byte[] n, string text, string se)
         {
             byte[] e = Hex.Decode(se);
             Assert.IsTrue(Arrays.AreEqual(e, n), text);
         }
 
-        private static void CheckX448Vector(String sk, String su, String se, String text)
+        private static void CheckX448Vector(string sk, string su, string se, string text)
         {
             byte[] k = Hex.Decode(sk);
+            Assert.AreEqual(X448.ScalarSize, k.Length);
+
             byte[] u = Hex.Decode(su);
-            byte[] r = new byte[56];
+            Assert.AreEqual(X448.PointSize, u.Length);
+
+            byte[] r = new byte[X448.PointSize];
             X448.ScalarMult(k, 0, u, 0, r, 0);
             CheckValue(r, text, se);
         }