diff options
| author | Peter Dettman <peter.dettman@bouncycastle.org> | 2022-07-18 13:01:35 +0700 |
|---|---|---|
| committer | Peter Dettman <peter.dettman@bouncycastle.org> | 2022-07-18 13:01:35 +0700 |
| commit | c8847bb09a42218bdcfa39732c5b776eb7b19b07 (patch) | |
| tree | 7b33c9742a03c34798b227775eb946fc79c6b7ad | |
| parent | Add SupportedOSPlatform attributes (diff) | |
| download | BouncyCastle.NET-ed25519-c8847bb09a42218bdcfa39732c5b776eb7b19b07.tar.xz | |
LongArray cleanup and refactoring
| -rw-r--r-- | crypto/src/math/ec/ECCurve.cs | 14 | ||||
| -rw-r--r-- | crypto/src/math/ec/LongArray.cs | 1228 | ||||
| -rw-r--r-- | crypto/src/math/raw/Interleave.cs | 52 |
3 files changed, 197 insertions, 1097 deletions
diff --git a/crypto/src/math/ec/ECCurve.cs b/crypto/src/math/ec/ECCurve.cs index 8b078c2a8..38e05991e 100644 --- a/crypto/src/math/ec/ECCurve.cs +++ b/crypto/src/math/ec/ECCurve.cs @@ -1351,7 +1351,7 @@ namespace Org.BouncyCastle.Math.EC { int FE_LONGS = (m + 63) / 64; - long[] table = new long[len * FE_LONGS * 2]; + ulong[] table = new ulong[len * FE_LONGS * 2]; { int pos = 0; for (int i = 0; i < len; ++i) @@ -1369,10 +1369,10 @@ namespace Org.BouncyCastle.Math.EC : AbstractECLookupTable { private readonly F2mCurve m_outer; - private readonly long[] m_table; + private readonly ulong[] m_table; private readonly int m_size; - internal DefaultF2mLookupTable(F2mCurve outer, long[] table, int size) + internal DefaultF2mLookupTable(F2mCurve outer, ulong[] table, int size) { this.m_outer = outer; this.m_table = table; @@ -1387,12 +1387,12 @@ namespace Org.BouncyCastle.Math.EC public override ECPoint Lookup(int index) { int FE_LONGS = (m_outer.m + 63) / 64; - long[] x = new long[FE_LONGS], y = new long[FE_LONGS]; + ulong[] x = new ulong[FE_LONGS], y = new ulong[FE_LONGS]; int pos = 0; for (int i = 0; i < m_size; ++i) { - long MASK =((i ^ index) - 1) >> 31; + ulong MASK = (ulong)(long)(((i ^ index) - 1) >> 31); for (int j = 0; j < FE_LONGS; ++j) { @@ -1409,7 +1409,7 @@ namespace Org.BouncyCastle.Math.EC public override ECPoint LookupVar(int index) { int FE_LONGS = (m_outer.m + 63) / 64; - long[] x = new long[FE_LONGS], y = new long[FE_LONGS]; + ulong[] x = new ulong[FE_LONGS], y = new ulong[FE_LONGS]; int pos = index * FE_LONGS * 2; for (int j = 0; j < FE_LONGS; ++j) @@ -1421,7 +1421,7 @@ namespace Org.BouncyCastle.Math.EC return CreatePoint(x, y); } - private ECPoint CreatePoint(long[] x, long[] y) + private ECPoint CreatePoint(ulong[] x, ulong[] y) { int m = m_outer.m; int[] ks = m_outer.IsTrinomial() diff --git a/crypto/src/math/ec/LongArray.cs b/crypto/src/math/ec/LongArray.cs index a6b834fbe..0cf32fd15 100644 --- a/crypto/src/math/ec/LongArray.cs +++ b/crypto/src/math/ec/LongArray.cs @@ -5,316 +5,32 @@ using Org.BouncyCastle.Utilities; namespace Org.BouncyCastle.Math.EC { - internal class LongArray + internal sealed class LongArray { - //private static long DEInterleave_MASK = 0x5555555555555555L; - - /* - * This expands 8 bit indices into 16 bit contents (high bit 14), by inserting 0s between bits. - * In a binary field, this operation is the same as squaring an 8 bit number. - */ - private static readonly ushort[] INTERLEAVE2_TABLE = new ushort[] - { - 0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015, - 0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055, - 0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115, - 0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155, - 0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415, - 0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455, - 0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515, - 0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555, - 0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015, - 0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055, - 0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115, - 0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155, - 0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415, - 0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455, - 0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515, - 0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555, - 0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015, - 0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055, - 0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115, - 0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155, - 0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415, - 0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455, - 0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515, - 0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555, - 0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015, - 0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055, - 0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115, - 0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155, - 0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415, - 0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455, - 0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515, - 0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555 - }; - - /* - * This expands 7 bit indices into 21 bit contents (high bit 18), by inserting 0s between bits. - */ - private static readonly int[] INTERLEAVE3_TABLE = new int[] - { - 0x00000, 0x00001, 0x00008, 0x00009, 0x00040, 0x00041, 0x00048, 0x00049, - 0x00200, 0x00201, 0x00208, 0x00209, 0x00240, 0x00241, 0x00248, 0x00249, - 0x01000, 0x01001, 0x01008, 0x01009, 0x01040, 0x01041, 0x01048, 0x01049, - 0x01200, 0x01201, 0x01208, 0x01209, 0x01240, 0x01241, 0x01248, 0x01249, - 0x08000, 0x08001, 0x08008, 0x08009, 0x08040, 0x08041, 0x08048, 0x08049, - 0x08200, 0x08201, 0x08208, 0x08209, 0x08240, 0x08241, 0x08248, 0x08249, - 0x09000, 0x09001, 0x09008, 0x09009, 0x09040, 0x09041, 0x09048, 0x09049, - 0x09200, 0x09201, 0x09208, 0x09209, 0x09240, 0x09241, 0x09248, 0x09249, - 0x40000, 0x40001, 0x40008, 0x40009, 0x40040, 0x40041, 0x40048, 0x40049, - 0x40200, 0x40201, 0x40208, 0x40209, 0x40240, 0x40241, 0x40248, 0x40249, - 0x41000, 0x41001, 0x41008, 0x41009, 0x41040, 0x41041, 0x41048, 0x41049, - 0x41200, 0x41201, 0x41208, 0x41209, 0x41240, 0x41241, 0x41248, 0x41249, - 0x48000, 0x48001, 0x48008, 0x48009, 0x48040, 0x48041, 0x48048, 0x48049, - 0x48200, 0x48201, 0x48208, 0x48209, 0x48240, 0x48241, 0x48248, 0x48249, - 0x49000, 0x49001, 0x49008, 0x49009, 0x49040, 0x49041, 0x49048, 0x49049, - 0x49200, 0x49201, 0x49208, 0x49209, 0x49240, 0x49241, 0x49248, 0x49249 - }; - - /* - * This expands 8 bit indices into 32 bit contents (high bit 28), by inserting 0s between bits. - */ - private static readonly int[] INTERLEAVE4_TABLE = new int[] - { - 0x00000000, 0x00000001, 0x00000010, 0x00000011, 0x00000100, 0x00000101, 0x00000110, 0x00000111, - 0x00001000, 0x00001001, 0x00001010, 0x00001011, 0x00001100, 0x00001101, 0x00001110, 0x00001111, - 0x00010000, 0x00010001, 0x00010010, 0x00010011, 0x00010100, 0x00010101, 0x00010110, 0x00010111, - 0x00011000, 0x00011001, 0x00011010, 0x00011011, 0x00011100, 0x00011101, 0x00011110, 0x00011111, - 0x00100000, 0x00100001, 0x00100010, 0x00100011, 0x00100100, 0x00100101, 0x00100110, 0x00100111, - 0x00101000, 0x00101001, 0x00101010, 0x00101011, 0x00101100, 0x00101101, 0x00101110, 0x00101111, - 0x00110000, 0x00110001, 0x00110010, 0x00110011, 0x00110100, 0x00110101, 0x00110110, 0x00110111, - 0x00111000, 0x00111001, 0x00111010, 0x00111011, 0x00111100, 0x00111101, 0x00111110, 0x00111111, - 0x01000000, 0x01000001, 0x01000010, 0x01000011, 0x01000100, 0x01000101, 0x01000110, 0x01000111, - 0x01001000, 0x01001001, 0x01001010, 0x01001011, 0x01001100, 0x01001101, 0x01001110, 0x01001111, - 0x01010000, 0x01010001, 0x01010010, 0x01010011, 0x01010100, 0x01010101, 0x01010110, 0x01010111, - 0x01011000, 0x01011001, 0x01011010, 0x01011011, 0x01011100, 0x01011101, 0x01011110, 0x01011111, - 0x01100000, 0x01100001, 0x01100010, 0x01100011, 0x01100100, 0x01100101, 0x01100110, 0x01100111, - 0x01101000, 0x01101001, 0x01101010, 0x01101011, 0x01101100, 0x01101101, 0x01101110, 0x01101111, - 0x01110000, 0x01110001, 0x01110010, 0x01110011, 0x01110100, 0x01110101, 0x01110110, 0x01110111, - 0x01111000, 0x01111001, 0x01111010, 0x01111011, 0x01111100, 0x01111101, 0x01111110, 0x01111111, - 0x10000000, 0x10000001, 0x10000010, 0x10000011, 0x10000100, 0x10000101, 0x10000110, 0x10000111, - 0x10001000, 0x10001001, 0x10001010, 0x10001011, 0x10001100, 0x10001101, 0x10001110, 0x10001111, - 0x10010000, 0x10010001, 0x10010010, 0x10010011, 0x10010100, 0x10010101, 0x10010110, 0x10010111, - 0x10011000, 0x10011001, 0x10011010, 0x10011011, 0x10011100, 0x10011101, 0x10011110, 0x10011111, - 0x10100000, 0x10100001, 0x10100010, 0x10100011, 0x10100100, 0x10100101, 0x10100110, 0x10100111, - 0x10101000, 0x10101001, 0x10101010, 0x10101011, 0x10101100, 0x10101101, 0x10101110, 0x10101111, - 0x10110000, 0x10110001, 0x10110010, 0x10110011, 0x10110100, 0x10110101, 0x10110110, 0x10110111, - 0x10111000, 0x10111001, 0x10111010, 0x10111011, 0x10111100, 0x10111101, 0x10111110, 0x10111111, - 0x11000000, 0x11000001, 0x11000010, 0x11000011, 0x11000100, 0x11000101, 0x11000110, 0x11000111, - 0x11001000, 0x11001001, 0x11001010, 0x11001011, 0x11001100, 0x11001101, 0x11001110, 0x11001111, - 0x11010000, 0x11010001, 0x11010010, 0x11010011, 0x11010100, 0x11010101, 0x11010110, 0x11010111, - 0x11011000, 0x11011001, 0x11011010, 0x11011011, 0x11011100, 0x11011101, 0x11011110, 0x11011111, - 0x11100000, 0x11100001, 0x11100010, 0x11100011, 0x11100100, 0x11100101, 0x11100110, 0x11100111, - 0x11101000, 0x11101001, 0x11101010, 0x11101011, 0x11101100, 0x11101101, 0x11101110, 0x11101111, - 0x11110000, 0x11110001, 0x11110010, 0x11110011, 0x11110100, 0x11110101, 0x11110110, 0x11110111, - 0x11111000, 0x11111001, 0x11111010, 0x11111011, 0x11111100, 0x11111101, 0x11111110, 0x11111111 - }; - - /* - * This expands 7 bit indices into 35 bit contents (high bit 30), by inserting 0s between bits. - */ - private static readonly int[] INTERLEAVE5_TABLE = new int[] { - 0x00000000, 0x00000001, 0x00000020, 0x00000021, 0x00000400, 0x00000401, 0x00000420, 0x00000421, - 0x00008000, 0x00008001, 0x00008020, 0x00008021, 0x00008400, 0x00008401, 0x00008420, 0x00008421, - 0x00100000, 0x00100001, 0x00100020, 0x00100021, 0x00100400, 0x00100401, 0x00100420, 0x00100421, - 0x00108000, 0x00108001, 0x00108020, 0x00108021, 0x00108400, 0x00108401, 0x00108420, 0x00108421, - 0x02000000, 0x02000001, 0x02000020, 0x02000021, 0x02000400, 0x02000401, 0x02000420, 0x02000421, - 0x02008000, 0x02008001, 0x02008020, 0x02008021, 0x02008400, 0x02008401, 0x02008420, 0x02008421, - 0x02100000, 0x02100001, 0x02100020, 0x02100021, 0x02100400, 0x02100401, 0x02100420, 0x02100421, - 0x02108000, 0x02108001, 0x02108020, 0x02108021, 0x02108400, 0x02108401, 0x02108420, 0x02108421, - 0x40000000, 0x40000001, 0x40000020, 0x40000021, 0x40000400, 0x40000401, 0x40000420, 0x40000421, - 0x40008000, 0x40008001, 0x40008020, 0x40008021, 0x40008400, 0x40008401, 0x40008420, 0x40008421, - 0x40100000, 0x40100001, 0x40100020, 0x40100021, 0x40100400, 0x40100401, 0x40100420, 0x40100421, - 0x40108000, 0x40108001, 0x40108020, 0x40108021, 0x40108400, 0x40108401, 0x40108420, 0x40108421, - 0x42000000, 0x42000001, 0x42000020, 0x42000021, 0x42000400, 0x42000401, 0x42000420, 0x42000421, - 0x42008000, 0x42008001, 0x42008020, 0x42008021, 0x42008400, 0x42008401, 0x42008420, 0x42008421, - 0x42100000, 0x42100001, 0x42100020, 0x42100021, 0x42100400, 0x42100401, 0x42100420, 0x42100421, - 0x42108000, 0x42108001, 0x42108020, 0x42108021, 0x42108400, 0x42108401, 0x42108420, 0x42108421 - }; - - /* - * This expands 9 bit indices into 63 bit (long) contents (high bit 56), by inserting 0s between bits. - */ - private static readonly long[] INTERLEAVE7_TABLE = new long[] - { - 0x0000000000000000L, 0x0000000000000001L, 0x0000000000000080L, 0x0000000000000081L, - 0x0000000000004000L, 0x0000000000004001L, 0x0000000000004080L, 0x0000000000004081L, - 0x0000000000200000L, 0x0000000000200001L, 0x0000000000200080L, 0x0000000000200081L, - 0x0000000000204000L, 0x0000000000204001L, 0x0000000000204080L, 0x0000000000204081L, - 0x0000000010000000L, 0x0000000010000001L, 0x0000000010000080L, 0x0000000010000081L, - 0x0000000010004000L, 0x0000000010004001L, 0x0000000010004080L, 0x0000000010004081L, - 0x0000000010200000L, 0x0000000010200001L, 0x0000000010200080L, 0x0000000010200081L, - 0x0000000010204000L, 0x0000000010204001L, 0x0000000010204080L, 0x0000000010204081L, - 0x0000000800000000L, 0x0000000800000001L, 0x0000000800000080L, 0x0000000800000081L, - 0x0000000800004000L, 0x0000000800004001L, 0x0000000800004080L, 0x0000000800004081L, - 0x0000000800200000L, 0x0000000800200001L, 0x0000000800200080L, 0x0000000800200081L, - 0x0000000800204000L, 0x0000000800204001L, 0x0000000800204080L, 0x0000000800204081L, - 0x0000000810000000L, 0x0000000810000001L, 0x0000000810000080L, 0x0000000810000081L, - 0x0000000810004000L, 0x0000000810004001L, 0x0000000810004080L, 0x0000000810004081L, - 0x0000000810200000L, 0x0000000810200001L, 0x0000000810200080L, 0x0000000810200081L, - 0x0000000810204000L, 0x0000000810204001L, 0x0000000810204080L, 0x0000000810204081L, - 0x0000040000000000L, 0x0000040000000001L, 0x0000040000000080L, 0x0000040000000081L, - 0x0000040000004000L, 0x0000040000004001L, 0x0000040000004080L, 0x0000040000004081L, - 0x0000040000200000L, 0x0000040000200001L, 0x0000040000200080L, 0x0000040000200081L, - 0x0000040000204000L, 0x0000040000204001L, 0x0000040000204080L, 0x0000040000204081L, - 0x0000040010000000L, 0x0000040010000001L, 0x0000040010000080L, 0x0000040010000081L, - 0x0000040010004000L, 0x0000040010004001L, 0x0000040010004080L, 0x0000040010004081L, - 0x0000040010200000L, 0x0000040010200001L, 0x0000040010200080L, 0x0000040010200081L, - 0x0000040010204000L, 0x0000040010204001L, 0x0000040010204080L, 0x0000040010204081L, - 0x0000040800000000L, 0x0000040800000001L, 0x0000040800000080L, 0x0000040800000081L, - 0x0000040800004000L, 0x0000040800004001L, 0x0000040800004080L, 0x0000040800004081L, - 0x0000040800200000L, 0x0000040800200001L, 0x0000040800200080L, 0x0000040800200081L, - 0x0000040800204000L, 0x0000040800204001L, 0x0000040800204080L, 0x0000040800204081L, - 0x0000040810000000L, 0x0000040810000001L, 0x0000040810000080L, 0x0000040810000081L, - 0x0000040810004000L, 0x0000040810004001L, 0x0000040810004080L, 0x0000040810004081L, - 0x0000040810200000L, 0x0000040810200001L, 0x0000040810200080L, 0x0000040810200081L, - 0x0000040810204000L, 0x0000040810204001L, 0x0000040810204080L, 0x0000040810204081L, - 0x0002000000000000L, 0x0002000000000001L, 0x0002000000000080L, 0x0002000000000081L, - 0x0002000000004000L, 0x0002000000004001L, 0x0002000000004080L, 0x0002000000004081L, - 0x0002000000200000L, 0x0002000000200001L, 0x0002000000200080L, 0x0002000000200081L, - 0x0002000000204000L, 0x0002000000204001L, 0x0002000000204080L, 0x0002000000204081L, - 0x0002000010000000L, 0x0002000010000001L, 0x0002000010000080L, 0x0002000010000081L, - 0x0002000010004000L, 0x0002000010004001L, 0x0002000010004080L, 0x0002000010004081L, - 0x0002000010200000L, 0x0002000010200001L, 0x0002000010200080L, 0x0002000010200081L, - 0x0002000010204000L, 0x0002000010204001L, 0x0002000010204080L, 0x0002000010204081L, - 0x0002000800000000L, 0x0002000800000001L, 0x0002000800000080L, 0x0002000800000081L, - 0x0002000800004000L, 0x0002000800004001L, 0x0002000800004080L, 0x0002000800004081L, - 0x0002000800200000L, 0x0002000800200001L, 0x0002000800200080L, 0x0002000800200081L, - 0x0002000800204000L, 0x0002000800204001L, 0x0002000800204080L, 0x0002000800204081L, - 0x0002000810000000L, 0x0002000810000001L, 0x0002000810000080L, 0x0002000810000081L, - 0x0002000810004000L, 0x0002000810004001L, 0x0002000810004080L, 0x0002000810004081L, - 0x0002000810200000L, 0x0002000810200001L, 0x0002000810200080L, 0x0002000810200081L, - 0x0002000810204000L, 0x0002000810204001L, 0x0002000810204080L, 0x0002000810204081L, - 0x0002040000000000L, 0x0002040000000001L, 0x0002040000000080L, 0x0002040000000081L, - 0x0002040000004000L, 0x0002040000004001L, 0x0002040000004080L, 0x0002040000004081L, - 0x0002040000200000L, 0x0002040000200001L, 0x0002040000200080L, 0x0002040000200081L, - 0x0002040000204000L, 0x0002040000204001L, 0x0002040000204080L, 0x0002040000204081L, - 0x0002040010000000L, 0x0002040010000001L, 0x0002040010000080L, 0x0002040010000081L, - 0x0002040010004000L, 0x0002040010004001L, 0x0002040010004080L, 0x0002040010004081L, - 0x0002040010200000L, 0x0002040010200001L, 0x0002040010200080L, 0x0002040010200081L, - 0x0002040010204000L, 0x0002040010204001L, 0x0002040010204080L, 0x0002040010204081L, - 0x0002040800000000L, 0x0002040800000001L, 0x0002040800000080L, 0x0002040800000081L, - 0x0002040800004000L, 0x0002040800004001L, 0x0002040800004080L, 0x0002040800004081L, - 0x0002040800200000L, 0x0002040800200001L, 0x0002040800200080L, 0x0002040800200081L, - 0x0002040800204000L, 0x0002040800204001L, 0x0002040800204080L, 0x0002040800204081L, - 0x0002040810000000L, 0x0002040810000001L, 0x0002040810000080L, 0x0002040810000081L, - 0x0002040810004000L, 0x0002040810004001L, 0x0002040810004080L, 0x0002040810004081L, - 0x0002040810200000L, 0x0002040810200001L, 0x0002040810200080L, 0x0002040810200081L, - 0x0002040810204000L, 0x0002040810204001L, 0x0002040810204080L, 0x0002040810204081L, - 0x0100000000000000L, 0x0100000000000001L, 0x0100000000000080L, 0x0100000000000081L, - 0x0100000000004000L, 0x0100000000004001L, 0x0100000000004080L, 0x0100000000004081L, - 0x0100000000200000L, 0x0100000000200001L, 0x0100000000200080L, 0x0100000000200081L, - 0x0100000000204000L, 0x0100000000204001L, 0x0100000000204080L, 0x0100000000204081L, - 0x0100000010000000L, 0x0100000010000001L, 0x0100000010000080L, 0x0100000010000081L, - 0x0100000010004000L, 0x0100000010004001L, 0x0100000010004080L, 0x0100000010004081L, - 0x0100000010200000L, 0x0100000010200001L, 0x0100000010200080L, 0x0100000010200081L, - 0x0100000010204000L, 0x0100000010204001L, 0x0100000010204080L, 0x0100000010204081L, - 0x0100000800000000L, 0x0100000800000001L, 0x0100000800000080L, 0x0100000800000081L, - 0x0100000800004000L, 0x0100000800004001L, 0x0100000800004080L, 0x0100000800004081L, - 0x0100000800200000L, 0x0100000800200001L, 0x0100000800200080L, 0x0100000800200081L, - 0x0100000800204000L, 0x0100000800204001L, 0x0100000800204080L, 0x0100000800204081L, - 0x0100000810000000L, 0x0100000810000001L, 0x0100000810000080L, 0x0100000810000081L, - 0x0100000810004000L, 0x0100000810004001L, 0x0100000810004080L, 0x0100000810004081L, - 0x0100000810200000L, 0x0100000810200001L, 0x0100000810200080L, 0x0100000810200081L, - 0x0100000810204000L, 0x0100000810204001L, 0x0100000810204080L, 0x0100000810204081L, - 0x0100040000000000L, 0x0100040000000001L, 0x0100040000000080L, 0x0100040000000081L, - 0x0100040000004000L, 0x0100040000004001L, 0x0100040000004080L, 0x0100040000004081L, - 0x0100040000200000L, 0x0100040000200001L, 0x0100040000200080L, 0x0100040000200081L, - 0x0100040000204000L, 0x0100040000204001L, 0x0100040000204080L, 0x0100040000204081L, - 0x0100040010000000L, 0x0100040010000001L, 0x0100040010000080L, 0x0100040010000081L, - 0x0100040010004000L, 0x0100040010004001L, 0x0100040010004080L, 0x0100040010004081L, - 0x0100040010200000L, 0x0100040010200001L, 0x0100040010200080L, 0x0100040010200081L, - 0x0100040010204000L, 0x0100040010204001L, 0x0100040010204080L, 0x0100040010204081L, - 0x0100040800000000L, 0x0100040800000001L, 0x0100040800000080L, 0x0100040800000081L, - 0x0100040800004000L, 0x0100040800004001L, 0x0100040800004080L, 0x0100040800004081L, - 0x0100040800200000L, 0x0100040800200001L, 0x0100040800200080L, 0x0100040800200081L, - 0x0100040800204000L, 0x0100040800204001L, 0x0100040800204080L, 0x0100040800204081L, - 0x0100040810000000L, 0x0100040810000001L, 0x0100040810000080L, 0x0100040810000081L, - 0x0100040810004000L, 0x0100040810004001L, 0x0100040810004080L, 0x0100040810004081L, - 0x0100040810200000L, 0x0100040810200001L, 0x0100040810200080L, 0x0100040810200081L, - 0x0100040810204000L, 0x0100040810204001L, 0x0100040810204080L, 0x0100040810204081L, - 0x0102000000000000L, 0x0102000000000001L, 0x0102000000000080L, 0x0102000000000081L, - 0x0102000000004000L, 0x0102000000004001L, 0x0102000000004080L, 0x0102000000004081L, - 0x0102000000200000L, 0x0102000000200001L, 0x0102000000200080L, 0x0102000000200081L, - 0x0102000000204000L, 0x0102000000204001L, 0x0102000000204080L, 0x0102000000204081L, - 0x0102000010000000L, 0x0102000010000001L, 0x0102000010000080L, 0x0102000010000081L, - 0x0102000010004000L, 0x0102000010004001L, 0x0102000010004080L, 0x0102000010004081L, - 0x0102000010200000L, 0x0102000010200001L, 0x0102000010200080L, 0x0102000010200081L, - 0x0102000010204000L, 0x0102000010204001L, 0x0102000010204080L, 0x0102000010204081L, - 0x0102000800000000L, 0x0102000800000001L, 0x0102000800000080L, 0x0102000800000081L, - 0x0102000800004000L, 0x0102000800004001L, 0x0102000800004080L, 0x0102000800004081L, - 0x0102000800200000L, 0x0102000800200001L, 0x0102000800200080L, 0x0102000800200081L, - 0x0102000800204000L, 0x0102000800204001L, 0x0102000800204080L, 0x0102000800204081L, - 0x0102000810000000L, 0x0102000810000001L, 0x0102000810000080L, 0x0102000810000081L, - 0x0102000810004000L, 0x0102000810004001L, 0x0102000810004080L, 0x0102000810004081L, - 0x0102000810200000L, 0x0102000810200001L, 0x0102000810200080L, 0x0102000810200081L, - 0x0102000810204000L, 0x0102000810204001L, 0x0102000810204080L, 0x0102000810204081L, - 0x0102040000000000L, 0x0102040000000001L, 0x0102040000000080L, 0x0102040000000081L, - 0x0102040000004000L, 0x0102040000004001L, 0x0102040000004080L, 0x0102040000004081L, - 0x0102040000200000L, 0x0102040000200001L, 0x0102040000200080L, 0x0102040000200081L, - 0x0102040000204000L, 0x0102040000204001L, 0x0102040000204080L, 0x0102040000204081L, - 0x0102040010000000L, 0x0102040010000001L, 0x0102040010000080L, 0x0102040010000081L, - 0x0102040010004000L, 0x0102040010004001L, 0x0102040010004080L, 0x0102040010004081L, - 0x0102040010200000L, 0x0102040010200001L, 0x0102040010200080L, 0x0102040010200081L, - 0x0102040010204000L, 0x0102040010204001L, 0x0102040010204080L, 0x0102040010204081L, - 0x0102040800000000L, 0x0102040800000001L, 0x0102040800000080L, 0x0102040800000081L, - 0x0102040800004000L, 0x0102040800004001L, 0x0102040800004080L, 0x0102040800004081L, - 0x0102040800200000L, 0x0102040800200001L, 0x0102040800200080L, 0x0102040800200081L, - 0x0102040800204000L, 0x0102040800204001L, 0x0102040800204080L, 0x0102040800204081L, - 0x0102040810000000L, 0x0102040810000001L, 0x0102040810000080L, 0x0102040810000081L, - 0x0102040810004000L, 0x0102040810004001L, 0x0102040810004080L, 0x0102040810004081L, - 0x0102040810200000L, 0x0102040810200001L, 0x0102040810200080L, 0x0102040810200081L, - 0x0102040810204000L, 0x0102040810204001L, 0x0102040810204080L, 0x0102040810204081L - }; - - // For toString(); must have length 64 - private const string ZEROES = "0000000000000000000000000000000000000000000000000000000000000000"; - - internal static readonly byte[] BitLengths = - { - 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 - }; - // TODO make m fixed for the LongArray, and hence compute T once and for all - private long[] m_ints; + private ulong[] m_data; public LongArray(int intLen) { - m_ints = new long[intLen]; + m_data = new ulong[intLen]; } - public LongArray(long[] ints) + public LongArray(ulong[] data) { - m_ints = ints; + m_data = data; } - public LongArray(long[] ints, int off, int len) + public LongArray(ulong[] data, int off, int len) { - if (off == 0 && len == ints.Length) + if (off == 0 && len == data.Length) { - m_ints = ints; + m_data = data; } else { - m_ints = new long[len]; - Array.Copy(ints, off, m_ints, 0, len); + m_data = new ulong[len]; + Array.Copy(data, off, m_data, 0, len); } } @@ -327,7 +43,7 @@ namespace Org.BouncyCastle.Math.EC if (bigInt.SignValue == 0) { - m_ints = new long[] { 0L }; + m_data = new ulong[]{ 0UL }; return; } @@ -342,11 +58,11 @@ namespace Org.BouncyCastle.Math.EC barrStart = 1; } int intLen = (barrLen + 7) / 8; - m_ints = new long[intLen]; + m_data = new ulong[intLen]; int iarrJ = intLen - 1; int rem = barrLen % 8 + barrStart; - long temp = 0; + ulong temp = 0; int barrI = barrStart; if (barrStart < rem) { @@ -356,7 +72,7 @@ namespace Org.BouncyCastle.Math.EC uint barrBarrI = barr[barrI]; temp |= barrBarrI; } - m_ints[iarrJ--] = temp; + m_data[iarrJ--] = temp; } for (; iarrJ >= 0; iarrJ--) @@ -368,25 +84,26 @@ namespace Org.BouncyCastle.Math.EC uint barrBarrI = barr[barrI++]; temp |= barrBarrI; } - m_ints[iarrJ] = temp; + m_data[iarrJ] = temp; } } - internal void CopyTo(long[] z, int zOff) + internal void CopyTo(ulong[] z, int zOff) { - Array.Copy(m_ints, 0, z, zOff, m_ints.Length); + Array.Copy(m_data, 0, z, zOff, m_data.Length); } public bool IsOne() { - long[] a = m_ints; - if (a[0] != 1L) + ulong[] a = m_data; + int aLen = a.Length; + if (aLen < 1 || a[0] != 1UL) { return false; } - for (int i = 1; i < a.Length; ++i) + for (int i = 1; i < aLen; ++i) { - if (a[i] != 0L) + if (a[i] != 0UL) { return false; } @@ -396,10 +113,10 @@ namespace Org.BouncyCastle.Math.EC public bool IsZero() { - long[] a = m_ints; + ulong[] a = m_data; for (int i = 0; i < a.Length; ++i) { - if (a[i] != 0L) + if (a[i] != 0UL) { return false; } @@ -409,12 +126,12 @@ namespace Org.BouncyCastle.Math.EC public int GetUsedLength() { - return GetUsedLengthFrom(m_ints.Length); + return GetUsedLengthFrom(m_data.Length); } public int GetUsedLengthFrom(int from) { - long[] a = m_ints; + ulong[] a = m_data; from = System.Math.Min(from, a.Length); if (from < 1) @@ -423,9 +140,9 @@ namespace Org.BouncyCastle.Math.EC } // Check if first element will act as sentinel - if (a[0] != 0) + if (a[0] != 0UL) { - while (a[--from] == 0) + while (a[--from] == 0UL) { } return from + 1; @@ -433,7 +150,7 @@ namespace Org.BouncyCastle.Math.EC do { - if (a[--from] != 0) + if (a[--from] != 0UL) { return from + 1; } @@ -445,17 +162,17 @@ namespace Org.BouncyCastle.Math.EC public int Degree() { - int i = m_ints.Length; - long w; + int i = m_data.Length; + ulong w; do { if (i == 0) { return 0; } - w = m_ints[--i]; + w = m_data[--i]; } - while (w == 0); + while (w == 0UL); return (i << 6) + BitLength(w); } @@ -463,76 +180,29 @@ namespace Org.BouncyCastle.Math.EC private int DegreeFrom(int limit) { int i = (int)(((uint)limit + 62) >> 6); - long w; + ulong w; do { if (i == 0) { return 0; } - w = m_ints[--i]; + w = m_data[--i]; } while (w == 0); return (i << 6) + BitLength(w); } - // private int lowestCoefficient() - // { - // for (int i = 0; i < m_ints.Length; ++i) - // { - // long mi = m_ints[i]; - // if (mi != 0) - // { - // int j = 0; - // while ((mi & 0xFFL) == 0) - // { - // j += 8; - // mi >>>= 8; - // } - // while ((mi & 1L) == 0) - // { - // ++j; - // mi >>>= 1; - // } - // return (i << 6) + j; - // } - // } - // return -1; - // } - - private static int BitLength(long w) + private static int BitLength(ulong w) { - int u = (int)((ulong)w >> 32), b; - if (u == 0) - { - u = (int)w; - b = 0; - } - else - { - b = 32; - } - - int t = (int)((uint)u >> 16), k; - if (t == 0) - { - t = (int)((uint)u >> 8); - k = (t == 0) ? BitLengths[u] : 8 + BitLengths[t]; - } - else - { - int v = (int)((uint)t >> 8); - k = (v == 0) ? 16 + BitLengths[t] : 24 + BitLengths[v]; - } - - return b + k; + return 64 - Longs.NumberOfLeadingZeros((long)w); } - private long[] ResizedInts(int newLen) + private ulong[] ResizedData(int newLen) { - long[] newInts = new long[newLen]; - Array.Copy(m_ints, 0, newInts, 0, System.Math.Min(m_ints.Length, newLen)); + ulong[] newInts = new ulong[newLen]; + Array.Copy(m_data, 0, newInts, 0, System.Math.Min(m_data.Length, newLen)); return newInts; } @@ -544,13 +214,13 @@ namespace Org.BouncyCastle.Math.EC return BigInteger.Zero; } - long highestInt = m_ints[usedLen - 1]; + ulong highestInt = m_data[usedLen - 1]; byte[] temp = new byte[8]; int barrI = 0; bool trailingZeroBytesDone = false; for (int j = 7; j >= 0; j--) { - byte thisByte = (byte)((ulong)highestInt >> (8 * j)); + byte thisByte = (byte)(highestInt >> (8 * j)); if (trailingZeroBytesDone || (thisByte != 0)) { trailingZeroBytesDone = true; @@ -568,93 +238,54 @@ namespace Org.BouncyCastle.Math.EC for (int iarrJ = usedLen - 2; iarrJ >= 0; iarrJ--) { - long mi = m_ints[iarrJ]; + ulong mi = m_data[iarrJ]; for (int j = 7; j >= 0; j--) { - barr[barrI++] = (byte)((ulong)mi >> (8 * j)); + barr[barrI++] = (byte)(mi >> (8 * j)); } } return new BigInteger(1, barr); } - // private static long shiftUp(long[] x, int xOff, int count) - // { - // long prev = 0; - // for (int i = 0; i < count; ++i) - // { - // long next = x[xOff + i]; - // x[xOff + i] = (next << 1) | prev; - // prev = next >>> 63; - // } - // return prev; - // } - - private static long ShiftUp(long[] x, int xOff, int count, int shift) + private static ulong ShiftUp(ulong[] x, int xOff, int count, int shift) { int shiftInv = 64 - shift; - long prev = 0; + ulong prev = 0UL; for (int i = 0; i < count; ++i) { - long next = x[xOff + i]; + ulong next = x[xOff + i]; x[xOff + i] = (next << shift) | prev; - prev = (long)((ulong)next >> shiftInv); + prev = next >> shiftInv; } return prev; } - private static long ShiftUp(long[] x, int xOff, long[] z, int zOff, int count, int shift) + private static ulong ShiftUp(ulong[] x, int xOff, ulong[] z, int zOff, int count, int shift) { int shiftInv = 64 - shift; - long prev = 0; + ulong prev = 0UL; for (int i = 0; i < count; ++i) { - long next = x[xOff + i]; + ulong next = x[xOff + i]; z[zOff + i] = (next << shift) | prev; - prev = (long)((ulong)next >> shiftInv); + prev = next >> shiftInv; } return prev; } public LongArray AddOne() { - if (m_ints.Length == 0) + if (m_data.Length == 0) { - return new LongArray(new long[]{ 1L }); + return new LongArray(new ulong[]{ 1UL }); } int resultLen = System.Math.Max(1, GetUsedLength()); - long[] ints = ResizedInts(resultLen); - ints[0] ^= 1L; - return new LongArray(ints); + ulong[] data = ResizedData(resultLen); + data[0] ^= 1UL; + return new LongArray(data); } - // private void addShiftedByBits(LongArray other, int bits) - // { - // int words = bits >>> 6; - // int shift = bits & 0x3F; - // - // if (shift == 0) - // { - // addShiftedByWords(other, words); - // return; - // } - // - // int otherUsedLen = other.GetUsedLength(); - // if (otherUsedLen == 0) - // { - // return; - // } - // - // int minLen = otherUsedLen + words + 1; - // if (minLen > m_ints.Length) - // { - // m_ints = resizedInts(minLen); - // } - // - // long carry = addShiftedByBits(m_ints, words, other.m_ints, 0, otherUsedLen, shift); - // m_ints[otherUsedLen + words] ^= carry; - // } - private void AddShiftedByBitsSafe(LongArray other, int otherDegree, int bits) { int otherLen = (int)((uint)(otherDegree + 63) >> 6); @@ -664,39 +295,39 @@ namespace Org.BouncyCastle.Math.EC if (shift == 0) { - Add(m_ints, words, other.m_ints, 0, otherLen); + Add(m_data, words, other.m_data, 0, otherLen); return; } - long carry = AddShiftedUp(m_ints, words, other.m_ints, 0, otherLen, shift); - if (carry != 0L) + ulong carry = AddShiftedUp(m_data, words, other.m_data, 0, otherLen, shift); + if (carry != 0UL) { - m_ints[otherLen + words] ^= carry; + m_data[otherLen + words] ^= carry; } } - private static long AddShiftedUp(long[] x, int xOff, long[] y, int yOff, int count, int shift) + private static ulong AddShiftedUp(ulong[] x, int xOff, ulong[] y, int yOff, int count, int shift) { int shiftInv = 64 - shift; - long prev = 0; + ulong prev = 0; for (int i = 0; i < count; ++i) { - long next = y[yOff + i]; + ulong next = y[yOff + i]; x[xOff + i] ^= (next << shift) | prev; - prev = (long)((ulong)next >> shiftInv); + prev = next >> shiftInv; } return prev; } - private static long AddShiftedDown(long[] x, int xOff, long[] y, int yOff, int count, int shift) + private static ulong AddShiftedDown(ulong[] x, int xOff, ulong[] y, int yOff, int count, int shift) { int shiftInv = 64 - shift; - long prev = 0; + ulong prev = 0; int i = count; while (--i >= 0) { - long next = y[yOff + i]; - x[xOff + i] ^= (long)((ulong)next >> shift) | prev; + ulong next = y[yOff + i]; + x[xOff + i] ^= (next >> shift) | prev; prev = next << shiftInv; } return prev; @@ -711,15 +342,15 @@ namespace Org.BouncyCastle.Math.EC } int minLen = otherUsedLen + words; - if (minLen > m_ints.Length) + if (minLen > m_data.Length) { - m_ints = ResizedInts(minLen); + m_data = ResizedData(minLen); } - Add(m_ints, words, other.m_ints, 0, otherUsedLen); + Add(m_data, words, other.m_data, 0, otherUsedLen); } - private static void Add(long[] x, int xOff, long[] y, int yOff, int count) + private static void Add(ulong[] x, int xOff, ulong[] y, int yOff, int count) { for (int i = 0; i < count; ++i) { @@ -727,7 +358,7 @@ namespace Org.BouncyCastle.Math.EC } } - private static void Add(long[] x, int xOff, long[] y, int yOff, long[] z, int zOff, int count) + private static void Add(ulong[] x, int xOff, ulong[] y, int yOff, ulong[] z, int zOff, int count) { for (int i = 0; i < count; ++i) { @@ -735,7 +366,7 @@ namespace Org.BouncyCastle.Math.EC } } - private static void AddBoth(long[] x, int xOff, long[] y1, int y1Off, long[] y2, int y2Off, int count) + private static void AddBoth(ulong[] x, int xOff, ulong[] y1, int y1Off, ulong[] y2, int y2Off, int count) { for (int i = 0; i < count; ++i) { @@ -743,22 +374,7 @@ namespace Org.BouncyCastle.Math.EC } } - private static void Distribute(long[] x, int src, int dst1, int dst2, int count) - { - for (int i = 0; i < count; ++i) - { - long v = x[src + i]; - x[dst1 + i] ^= v; - x[dst2 + i] ^= v; - } - } - - public int Length - { - get { return m_ints.Length; } - } - - private static void FlipWord(long[] buf, int off, int bit, long word) + private static void FlipWord(ulong[] buf, int off, int bit, ulong word) { int n = off + (int)((uint)bit >> 6); int shift = bit & 0x3F; @@ -769,7 +385,7 @@ namespace Org.BouncyCastle.Math.EC else { buf[n] ^= word << shift; - word = (long)((ulong)word >> (64 - shift)); + word = word >> (64 - shift); if (word != 0) { buf[++n] ^= word; @@ -777,80 +393,44 @@ namespace Org.BouncyCastle.Math.EC } } - // private static long getWord(long[] buf, int off, int len, int bit) - // { - // int n = off + (bit >>> 6); - // int shift = bit & 0x3F; - // if (shift == 0) - // { - // return buf[n]; - // } - // long result = buf[n] >>> shift; - // if (++n < len) - // { - // result |= buf[n] << (64 - shift); - // } - // return result; - // } - public bool TestBitZero() { - return m_ints.Length > 0 && (m_ints[0] & 1L) != 0; + return m_data.Length > 0 && (m_data[0] & 1UL) != 0; } - private static bool TestBit(long[] buf, int off, int n) + private static bool TestBit(ulong[] buf, int off, int n) { // theInt = n / 64 int theInt = (int)((uint)n >> 6); // theBit = n % 64 int theBit = n & 0x3F; - long tester = 1L << theBit; - return (buf[off + theInt] & tester) != 0; + ulong tester = 1UL << theBit; + return (buf[off + theInt] & tester) != 0UL; } - private static void FlipBit(long[] buf, int off, int n) + private static void FlipBit(ulong[] buf, int off, int n) { // theInt = n / 64 int theInt = (int)((uint)n >> 6); // theBit = n % 64 int theBit = n & 0x3F; - long flipper = 1L << theBit; + ulong flipper = 1UL << theBit; buf[off + theInt] ^= flipper; } - // private static void SetBit(long[] buf, int off, int n) - // { - // // theInt = n / 64 - // int theInt = n >>> 6; - // // theBit = n % 64 - // int theBit = n & 0x3F; - // long setter = 1L << theBit; - // buf[off + theInt] |= setter; - // } - // - // private static void ClearBit(long[] buf, int off, int n) - // { - // // theInt = n / 64 - // int theInt = n >>> 6; - // // theBit = n % 64 - // int theBit = n & 0x3F; - // long setter = 1L << theBit; - // buf[off + theInt] &= ~setter; - // } - - private static void MultiplyWord(long a, long[] b, int bLen, long[] c, int cOff) + private static void MultiplyWord(ulong a, ulong[] b, int bLen, ulong[] c, int cOff) { - if ((a & 1L) != 0L) + if ((a & 1UL) != 0UL) { Add(c, cOff, b, 0, bLen); } int k = 1; - while ((a = (long)((ulong)a >> 1)) != 0L) + while ((a >>= 1) != 0UL) { - if ((a & 1L) != 0L) + if ((a & 1UL) != 0UL) { - long carry = AddShiftedUp(c, cOff, b, 0, bLen, k); - if (carry != 0L) + ulong carry = AddShiftedUp(c, cOff, b, 0, bLen, k); + if (carry != 0UL) { c[cOff + bLen] ^= carry; } @@ -894,8 +474,8 @@ namespace Org.BouncyCastle.Math.EC if (aLen == 1) { - long a0 = A.m_ints[0]; - if (a0 == 1L) + ulong a0 = A.m_data[0]; + if (a0 == 1UL) { return B; } @@ -903,8 +483,8 @@ namespace Org.BouncyCastle.Math.EC /* * Fast path for small A, with performance dependent only on the number of set bits */ - long[] c0 = new long[cLen]; - MultiplyWord(a0, B.m_ints, bLen, c0, 0); + ulong[] c0 = new ulong[cLen]; + MultiplyWord(a0, B.m_data, bLen, c0, 0); /* * Reduce the raw answer against the reduction coefficients @@ -925,10 +505,10 @@ namespace Org.BouncyCastle.Math.EC /* * Precompute table of all 4-bit products of B */ - long[] T0 = new long[bMax << 4]; + ulong[] T0 = new ulong[bMax << 4]; int tOff = bMax; ti[1] = tOff; - Array.Copy(B.m_ints, 0, T0, tOff, bLen); + Array.Copy(B.m_data, 0, T0, tOff, bLen); for (int i = 2; i < 16; ++i) { ti[i] = (tOff += bMax); @@ -945,14 +525,14 @@ namespace Org.BouncyCastle.Math.EC /* * Second table with all 4-bit products of B shifted 4 bits */ - long[] T1 = new long[T0.Length]; + ulong[] T1 = new ulong[T0.Length]; ShiftUp(T0, 0, T1, 0, T0.Length, 4); // shiftUp(T0, bMax, T1, bMax, tOff, 4); - long[] a = A.m_ints; - long[] c = new long[cLen]; + ulong[] a = A.m_data; + ulong[] c = new ulong[cLen]; - int MASK = 0xF; + uint MASK = 0xF; /* * Lopez-Dahab algorithm @@ -962,9 +542,9 @@ namespace Org.BouncyCastle.Math.EC { for (int j = 1; j < aLen; j += 2) { - int aVal = (int)((ulong)a[j] >> k); - int u = aVal & MASK; - int v = (int)((uint)aVal >> 4) & MASK; + uint aVal = (uint)(a[j] >> k); + uint u = aVal & MASK; + uint v = (aVal >> 4) & MASK; AddBoth(c, j - 1, T0, ti[u], T1, ti[v], bMax); } ShiftUp(c, 0, cLen, 8); @@ -974,9 +554,9 @@ namespace Org.BouncyCastle.Math.EC { for (int j = 0; j < aLen; j += 2) { - int aVal = (int)((ulong)a[j] >> k); - int u = aVal & MASK; - int v = (int)((uint)aVal >> 4) & MASK; + uint aVal = (uint)(a[j] >> k); + uint u = aVal & MASK; + uint v = (aVal >> 4) & MASK; AddBoth(c, j, T0, ti[u], T1, ti[v], bMax); } if (k > 0) @@ -1026,8 +606,8 @@ namespace Org.BouncyCastle.Math.EC if (aLen == 1) { - long a0 = A.m_ints[0]; - if (a0 == 1L) + ulong a0 = A.m_data[0]; + if (a0 == 1UL) { return B; } @@ -1035,8 +615,8 @@ namespace Org.BouncyCastle.Math.EC /* * Fast path for small A, with performance dependent only on the number of set bits */ - long[] c0 = new long[cLen]; - MultiplyWord(a0, B.m_ints, bLen, c0, 0); + ulong[] c0 = new ulong[cLen]; + MultiplyWord(a0, B.m_data, bLen, c0, 0); /* * Reduce the raw answer against the reduction coefficients @@ -1057,13 +637,14 @@ namespace Org.BouncyCastle.Math.EC /* * Precompute table of all 4-bit products of B */ - long[] T0 = new long[bMax << 4]; + ulong[] T0 = new ulong[bMax << 4]; int tOff = bMax; ti[1] = tOff; - Array.Copy(B.m_ints, 0, T0, tOff, bLen); + Array.Copy(B.m_data, 0, T0, tOff, bLen); for (int i = 2; i < 16; ++i) { - ti[i] = (tOff += bMax); + tOff += bMax; + ti[i] = tOff; if ((i & 1) == 0) { ShiftUp(T0, (int)((uint)tOff >> 1), T0, tOff, bMax, 1); @@ -1077,14 +658,14 @@ namespace Org.BouncyCastle.Math.EC /* * Second table with all 4-bit products of B shifted 4 bits */ - long[] T1 = new long[T0.Length]; + ulong[] T1 = new ulong[T0.Length]; ShiftUp(T0, 0, T1, 0, T0.Length, 4); // ShiftUp(T0, bMax, T1, bMax, tOff, 4); - long[] a = A.m_ints; - long[] c = new long[cLen << 3]; + ulong[] a = A.m_data; + ulong[] c = new ulong[cLen << 3]; - int MASK = 0xF; + uint MASK = 0xF; /* * Lopez-Dahab (Modified) algorithm @@ -1092,16 +673,14 @@ namespace Org.BouncyCastle.Math.EC for (int aPos = 0; aPos < aLen; ++aPos) { - long aVal = a[aPos]; + ulong aVal = a[aPos]; int cOff = aPos; for (;;) { - int u = (int)aVal & MASK; - aVal = (long)((ulong)aVal >> 4); - int v = (int)aVal & MASK; + uint u = (uint)aVal & MASK; aVal >>= 4; + uint v = (uint)aVal & MASK; aVal >>= 4; AddBoth(c, cOff, T0, ti[u], T1, ti[v], bMax); - aVal = (long)((ulong)aVal >> 4); - if (aVal == 0L) + if (aVal == 0UL) { break; } @@ -1123,229 +702,12 @@ namespace Org.BouncyCastle.Math.EC return ReduceResult(c, 0, cLen, m, ks); } - public LongArray ModMultiplyAlt(LongArray other, int m, int[] ks) - { - /* - * Find out the degree of each argument and handle the zero cases - */ - int aDeg = Degree(); - if (aDeg == 0) - { - return this; - } - int bDeg = other.Degree(); - if (bDeg == 0) - { - return other; - } - - /* - * Swap if necessary so that A is the smaller argument - */ - LongArray A = this, B = other; - if (aDeg > bDeg) - { - A = other; B = this; - int tmp = aDeg; aDeg = bDeg; bDeg = tmp; - } - - /* - * Establish the word lengths of the arguments and result - */ - int aLen = (int)((uint)(aDeg + 63) >> 6); - int bLen = (int)((uint)(bDeg + 63) >> 6); - int cLen = (int)((uint)(aDeg + bDeg + 62) >> 6); - - if (aLen == 1) - { - long a0 = A.m_ints[0]; - if (a0 == 1L) - { - return B; - } - - /* - * Fast path for small A, with performance dependent only on the number of set bits - */ - long[] c0 = new long[cLen]; - MultiplyWord(a0, B.m_ints, bLen, c0, 0); - - /* - * Reduce the raw answer against the reduction coefficients - */ - return ReduceResult(c0, 0, cLen, m, ks); - } - - // NOTE: This works, but is slower than width 4 processing - // if (aLen == 2) - // { - // /* - // * Use common-multiplicand optimization to save ~1/4 of the adds - // */ - // long a1 = A.m_ints[0], a2 = A.m_ints[1]; - // long aa = a1 & a2; a1 ^= aa; a2 ^= aa; - // - // long[] b = B.m_ints; - // long[] c = new long[cLen]; - // multiplyWord(aa, b, bLen, c, 1); - // add(c, 0, c, 1, cLen - 1); - // multiplyWord(a1, b, bLen, c, 0); - // multiplyWord(a2, b, bLen, c, 1); - // - // /* - // * Reduce the raw answer against the reduction coefficients - // */ - // return ReduceResult(c, 0, cLen, m, ks); - // } - - /* - * Determine the parameters of the Interleaved window algorithm: the 'width' in bits to - * process together, the number of evaluation 'positions' implied by that width, and the - * 'top' position at which the regular window algorithm stops. - */ - int width, positions, top, banks; - - // NOTE: width 4 is the fastest over the entire range of sizes used in current crypto - // width = 1; positions = 64; top = 64; banks = 4; - // width = 2; positions = 32; top = 64; banks = 4; - // width = 3; positions = 21; top = 63; banks = 3; - width = 4; positions = 16; top = 64; banks = 8; - // width = 5; positions = 13; top = 65; banks = 7; - // width = 7; positions = 9; top = 63; banks = 9; - // width = 8; positions = 8; top = 64; banks = 8; - - /* - * Determine if B will get bigger during shifting - */ - int shifts = top < 64 ? positions : positions - 1; - int bMax = (int)((uint)(bDeg + shifts + 63) >> 6); - - int bTotal = bMax * banks, stride = width * banks; - - /* - * Create a single temporary buffer, with an offset table to find the positions of things in it - */ - int[] ci = new int[1 << width]; - int cTotal = aLen; - { - ci[0] = cTotal; - cTotal += bTotal; - ci[1] = cTotal; - for (int i = 2; i < ci.Length; ++i) - { - cTotal += cLen; - ci[i] = cTotal; - } - cTotal += cLen; - } - // NOTE: Provide a safe dump for "high zeroes" since we are adding 'bMax' and not 'bLen' - ++cTotal; - - long[] c = new long[cTotal]; - - // Prepare A in Interleaved form, according to the chosen width - Interleave(A.m_ints, 0, c, 0, aLen, width); - - // Make a working copy of B, since we will be shifting it - { - int bOff = aLen; - Array.Copy(B.m_ints, 0, c, bOff, bLen); - for (int bank = 1; bank < banks; ++bank) - { - ShiftUp(c, aLen, c, bOff += bMax, bMax, bank); - } - } - - /* - * The main loop analyzes the Interleaved windows in A, and for each non-zero window - * a single word-array XOR is performed to a carefully selected slice of 'c'. The loop is - * breadth-first, checking the lowest window in each word, then looping again for the - * next higher window position. - */ - int MASK = (1 << width) - 1; - - int k = 0; - for (;;) - { - int aPos = 0; - do - { - long aVal = (long)((ulong)c[aPos] >> k); - int bank = 0, bOff = aLen; - for (;;) - { - int index = (int)(aVal) & MASK; - if (index != 0) - { - /* - * Add to a 'c' buffer based on the bit-pattern of 'index'. Since A is in - * Interleaved form, the bits represent the current B shifted by 0, 'positions', - * 'positions' * 2, ..., 'positions' * ('width' - 1) - */ - Add(c, aPos + ci[index], c, bOff, bMax); - } - if (++bank == banks) - { - break; - } - bOff += bMax; - aVal = (long)((ulong)aVal >> width); - } - } - while (++aPos < aLen); - - if ((k += stride) >= top) - { - if (k >= 64) - { - break; - } - - /* - * Adjustment for window setups with top == 63, the final bit (if any) is processed - * as the top-bit of a window - */ - k = 64 - width; - MASK &= MASK << (top - k); - } - - /* - * After each position has been checked for all words of A, B is shifted up 1 place - */ - ShiftUp(c, aLen, bTotal, banks); - } - - int ciPos = ci.Length; - while (--ciPos > 1) - { - if ((ciPos & 1L) == 0L) - { - /* - * For even numbers, shift contents and add to the half-position - */ - AddShiftedUp(c, ci[(uint)ciPos >> 1], c, ci[ciPos], cLen, positions); - } - else - { - /* - * For odd numbers, 'distribute' contents to the result and the next-lowest position - */ - Distribute(c, ci[ciPos], ci[ciPos - 1], ci[1], cLen); - } - } - - /* - * Finally the raw answer is collected, reduce it against the reduction coefficients - */ - return ReduceResult(c, ci[1], cLen, m, ks); - } - - public LongArray ModReduce(int m, int[] ks) - { - long[] buf = Arrays.Clone(m_ints); - int rLen = ReduceInPlace(buf, 0, buf.Length, m, ks); - return new LongArray(buf, 0, rLen); - } + //public LongArray ModReduce(int m, int[] ks) + //{ + // ulong[] buf = Arrays.Clone(m_data); + // int rLen = ReduceInPlace(buf, 0, buf.Length, m, ks); + // return new LongArray(buf, 0, rLen); + //} public LongArray Multiply(LongArray other, int m, int[] ks) { @@ -1382,8 +744,8 @@ namespace Org.BouncyCastle.Math.EC if (aLen == 1) { - long a0 = A.m_ints[0]; - if (a0 == 1L) + ulong a0 = A.m_data[0]; + if (a0 == 1UL) { return B; } @@ -1391,8 +753,8 @@ namespace Org.BouncyCastle.Math.EC /* * Fast path for small A, with performance dependent only on the number of set bits */ - long[] c0 = new long[cLen]; - MultiplyWord(a0, B.m_ints, bLen, c0, 0); + ulong[] c0 = new ulong[cLen]; + MultiplyWord(a0, B.m_data, bLen, c0, 0); /* * Reduce the raw answer against the reduction coefficients @@ -1414,13 +776,14 @@ namespace Org.BouncyCastle.Math.EC /* * Precompute table of all 4-bit products of B */ - long[] T0 = new long[bMax << 4]; + ulong[] T0 = new ulong[bMax << 4]; int tOff = bMax; ti[1] = tOff; - Array.Copy(B.m_ints, 0, T0, tOff, bLen); + Array.Copy(B.m_data, 0, T0, tOff, bLen); for (int i = 2; i < 16; ++i) { - ti[i] = (tOff += bMax); + tOff += bMax; + ti[i] = tOff; if ((i & 1) == 0) { ShiftUp(T0, (int)((uint)tOff >> 1), T0, tOff, bMax, 1); @@ -1434,14 +797,14 @@ namespace Org.BouncyCastle.Math.EC /* * Second table with all 4-bit products of B shifted 4 bits */ - long[] T1 = new long[T0.Length]; + ulong[] T1 = new ulong[T0.Length]; ShiftUp(T0, 0, T1, 0, T0.Length, 4); - // ShiftUp(T0, bMax, T1, bMax, tOff, 4); + //ShiftUp(T0, bMax, T1, bMax, tOff, 4); - long[] a = A.m_ints; - long[] c = new long[cLen << 3]; + ulong[] a = A.m_data; + ulong[] c = new ulong[cLen << 3]; - int MASK = 0xF; + uint MASK = 0xF; /* * Lopez-Dahab (Modified) algorithm @@ -1449,16 +812,14 @@ namespace Org.BouncyCastle.Math.EC for (int aPos = 0; aPos < aLen; ++aPos) { - long aVal = a[aPos]; + ulong aVal = a[aPos]; int cOff = aPos; for (; ; ) { - int u = (int)aVal & MASK; - aVal = (long)((ulong)aVal >> 4); - int v = (int)aVal & MASK; + uint u = (uint)aVal & MASK; aVal >>= 4; + uint v = (uint)aVal & MASK; aVal >>= 4; AddBoth(c, cOff, T0, ti[u], T1, ti[v], bMax); - aVal = (long)((ulong)aVal >> 4); - if (aVal == 0L) + if (aVal == 0UL) { break; } @@ -1483,49 +844,22 @@ namespace Org.BouncyCastle.Math.EC public void Reduce(int m, int[] ks) { - long[] buf = m_ints; + ulong[] buf = m_data; int rLen = ReduceInPlace(buf, 0, buf.Length, m, ks); if (rLen < buf.Length) { - m_ints = new long[rLen]; - Array.Copy(buf, 0, m_ints, 0, rLen); + m_data = new ulong[rLen]; + Array.Copy(buf, 0, m_data, 0, rLen); } } - private static LongArray ReduceResult(long[] buf, int off, int len, int m, int[] ks) + private static LongArray ReduceResult(ulong[] buf, int off, int len, int m, int[] ks) { int rLen = ReduceInPlace(buf, off, len, m, ks); return new LongArray(buf, off, rLen); } - // private static void deInterleave(long[] x, int xOff, long[] z, int zOff, int count, int rounds) - // { - // for (int i = 0; i < count; ++i) - // { - // z[zOff + i] = deInterleave(x[zOff + i], rounds); - // } - // } - // - // private static long deInterleave(long x, int rounds) - // { - // while (--rounds >= 0) - // { - // x = deInterleave32(x & DEInterleave_MASK) | (deInterleave32((x >>> 1) & DEInterleave_MASK) << 32); - // } - // return x; - // } - // - // private static long deInterleave32(long x) - // { - // x = (x | (x >>> 1)) & 0x3333333333333333L; - // x = (x | (x >>> 2)) & 0x0F0F0F0F0F0F0F0FL; - // x = (x | (x >>> 4)) & 0x00FF00FF00FF00FFL; - // x = (x | (x >>> 8)) & 0x0000FFFF0000FFFFL; - // x = (x | (x >>> 16)) & 0x00000000FFFFFFFFL; - // return x; - // } - - private static int ReduceInPlace(long[] buf, int off, int len, int m, int[] ks) + private static int ReduceInPlace(ulong[] buf, int off, int len, int m, int[] ks) { int mLen = (m + 63) >> 6; if (len < mLen) @@ -1569,7 +903,7 @@ namespace Org.BouncyCastle.Math.EC return mLen; } - private static void ReduceBitWise(long[] buf, int off, int BitLength, int m, int[] ks) + private static void ReduceBitWise(ulong[] buf, int off, int BitLength, int m, int[] ks) { while (--BitLength >= m) { @@ -1580,7 +914,7 @@ namespace Org.BouncyCastle.Math.EC } } - private static void ReduceBit(long[] buf, int off, int bit, int m, int[] ks) + private static void ReduceBit(ulong[] buf, int off, int bit, int m, int[] ks) { FlipBit(buf, off, bit); int n = bit - m; @@ -1592,23 +926,23 @@ namespace Org.BouncyCastle.Math.EC FlipBit(buf, off, n); } - private static void ReduceWordWise(long[] buf, int off, int len, int toBit, int m, int[] ks) + private static void ReduceWordWise(ulong[] buf, int off, int len, int toBit, int m, int[] ks) { int toPos = (int)((uint)toBit >> 6); while (--len > toPos) { - long word = buf[off + len]; + ulong word = buf[off + len]; if (word != 0) { - buf[off + len] = 0; + buf[off + len] = 0UL; ReduceWord(buf, off, (len << 6), word, m, ks); } } { int partial = toBit & 0x3F; - long word = (long)((ulong)buf[off + toPos] >> partial); + ulong word = buf[off + toPos] >> partial; if (word != 0) { buf[off + toPos] ^= word << partial; @@ -1617,7 +951,7 @@ namespace Org.BouncyCastle.Math.EC } } - private static void ReduceWord(long[] buf, int off, int bit, long word, int m, int[] ks) + private static void ReduceWord(ulong[] buf, int off, int bit, ulong word, int m, int[] ks) { int offset = bit - m; int j = ks.Length; @@ -1628,7 +962,7 @@ namespace Org.BouncyCastle.Math.EC FlipWord(buf, off, offset, word); } - private static void ReduceVectorWise(long[] buf, int off, int len, int words, int m, int[] ks) + private static void ReduceVectorWise(ulong[] buf, int off, int len, int words, int m, int[] ks) { /* * NOTE: It's important we go from highest coefficient to lowest, because for the highest @@ -1644,7 +978,7 @@ namespace Org.BouncyCastle.Math.EC FlipVector(buf, off, buf, off + words, len - words, baseBit); } - private static void FlipVector(long[] x, int xOff, long[] y, int yOff, int yLen, int bits) + private static void FlipVector(ulong[] x, int xOff, ulong[] y, int yOff, int yLen, int bits) { xOff += (int)((uint)bits >> 6); bits &= 0x3F; @@ -1655,7 +989,7 @@ namespace Org.BouncyCastle.Math.EC } else { - long carry = AddShiftedDown(x, xOff + 1, y, yOff, yLen, 64 - bits); + ulong carry = AddShiftedDown(x, xOff + 1, y, yOff, yLen, 64 - bits); x[xOff] ^= carry; } } @@ -1664,20 +998,10 @@ namespace Org.BouncyCastle.Math.EC { int len = GetUsedLength(); if (len == 0) - { return this; - } - - int _2len = len << 1; - long[] r = new long[_2len]; - int pos = 0; - while (pos < _2len) - { - long mi = m_ints[(uint)pos >> 1]; - r[pos++] = Interleave2_32to64((int)mi); - r[pos++] = Interleave2_32to64((int)((ulong)mi >> 32)); - } + ulong[] r = new ulong[len << 1]; + Raw.Interleave.Expand64To128(m_data, 0, len, r, 0); return new LongArray(r, 0, ReduceInPlace(r, 0, r.Length, m, ks)); } @@ -1686,17 +1010,15 @@ namespace Org.BouncyCastle.Math.EC { int len = GetUsedLength(); if (len == 0) - { return this; - } - + int mLen = (m + 63) >> 6; - long[] r = new long[mLen << 1]; - Array.Copy(m_ints, 0, r, 0, len); - + ulong[] r = new ulong[mLen << 1]; + Array.Copy(m_data, 0, r, 0, len); + while (--n >= 0) { - SquareInPlace(r, len, m, ks); + Raw.Interleave.Expand64To128(r, 0, len); len = ReduceInPlace(r, 0, r.Length, m, ks); } @@ -1707,207 +1029,14 @@ namespace Org.BouncyCastle.Math.EC { int len = GetUsedLength(); if (len == 0) - { return this; - } - - int _2len = len << 1; - long[] r = new long[_2len]; - int pos = 0; - while (pos < _2len) - { - long mi = m_ints[(uint)pos >> 1]; - r[pos++] = Interleave2_32to64((int)mi); - r[pos++] = Interleave2_32to64((int)((ulong)mi >> 32)); - } + ulong[] r = new ulong[len << 1]; + Raw.Interleave.Expand64To128(m_data, 0, len, r, 0); return new LongArray(r, 0, r.Length); } - private static void SquareInPlace(long[] x, int xLen, int m, int[] ks) - { - int pos = xLen << 1; - while (--xLen >= 0) - { - long xVal = x[xLen]; - x[--pos] = Interleave2_32to64((int)((ulong)xVal >> 32)); - x[--pos] = Interleave2_32to64((int)xVal); - } - } - - private static void Interleave(long[] x, int xOff, long[] z, int zOff, int count, int width) - { - switch (width) - { - case 3: - Interleave3(x, xOff, z, zOff, count); - break; - case 5: - Interleave5(x, xOff, z, zOff, count); - break; - case 7: - Interleave7(x, xOff, z, zOff, count); - break; - default: - Interleave2_n(x, xOff, z, zOff, count, BitLengths[width] - 1); - break; - } - } - - private static void Interleave3(long[] x, int xOff, long[] z, int zOff, int count) - { - for (int i = 0; i < count; ++i) - { - z[zOff + i] = Interleave3(x[xOff + i]); - } - } - - private static long Interleave3(long x) - { - long z = x & (1L << 63); - return z - | Interleave3_21to63((int)x & 0x1FFFFF) - | Interleave3_21to63((int)((ulong)x >> 21) & 0x1FFFFF) << 1 - | Interleave3_21to63((int)((ulong)x >> 42) & 0x1FFFFF) << 2; - - // int zPos = 0, wPos = 0, xPos = 0; - // for (;;) - // { - // z |= ((x >>> xPos) & 1L) << zPos; - // if (++zPos == 63) - // { - // String sz2 = Long.toBinaryString(z); - // return z; - // } - // if ((xPos += 21) >= 63) - // { - // xPos = ++wPos; - // } - // } - } - - private static long Interleave3_21to63(int x) - { - int r00 = INTERLEAVE3_TABLE[x & 0x7F]; - int r21 = INTERLEAVE3_TABLE[((uint)x >> 7) & 0x7F]; - int r42 = INTERLEAVE3_TABLE[(uint)x >> 14]; - return (r42 & 0xFFFFFFFFL) << 42 | (r21 & 0xFFFFFFFFL) << 21 | (r00 & 0xFFFFFFFFL); - } - - private static void Interleave5(long[] x, int xOff, long[] z, int zOff, int count) - { - for (int i = 0; i < count; ++i) - { - z[zOff + i] = Interleave5(x[xOff + i]); - } - } - - private static long Interleave5(long x) - { - return Interleave3_13to65((int)x & 0x1FFF) - | Interleave3_13to65((int)((ulong)x >> 13) & 0x1FFF) << 1 - | Interleave3_13to65((int)((ulong)x >> 26) & 0x1FFF) << 2 - | Interleave3_13to65((int)((ulong)x >> 39) & 0x1FFF) << 3 - | Interleave3_13to65((int)((ulong)x >> 52) & 0x1FFF) << 4; - - // long z = 0; - // int zPos = 0, wPos = 0, xPos = 0; - // for (;;) - // { - // z |= ((x >>> xPos) & 1L) << zPos; - // if (++zPos == 64) - // { - // return z; - // } - // if ((xPos += 13) >= 64) - // { - // xPos = ++wPos; - // } - // } - } - - private static long Interleave3_13to65(int x) - { - int r00 = INTERLEAVE5_TABLE[x & 0x7F]; - int r35 = INTERLEAVE5_TABLE[(uint)x >> 7]; - return (r35 & 0xFFFFFFFFL) << 35 | (r00 & 0xFFFFFFFFL); - } - - private static void Interleave7(long[] x, int xOff, long[] z, int zOff, int count) - { - for (int i = 0; i < count; ++i) - { - z[zOff + i] = Interleave7(x[xOff + i]); - } - } - - private static long Interleave7(long x) - { - long z = x & (1L << 63); - return z - | INTERLEAVE7_TABLE[(int)x & 0x1FF] - | INTERLEAVE7_TABLE[(int)((ulong)x >> 9) & 0x1FF] << 1 - | INTERLEAVE7_TABLE[(int)((ulong)x >> 18) & 0x1FF] << 2 - | INTERLEAVE7_TABLE[(int)((ulong)x >> 27) & 0x1FF] << 3 - | INTERLEAVE7_TABLE[(int)((ulong)x >> 36) & 0x1FF] << 4 - | INTERLEAVE7_TABLE[(int)((ulong)x >> 45) & 0x1FF] << 5 - | INTERLEAVE7_TABLE[(int)((ulong)x >> 54) & 0x1FF] << 6; - - // int zPos = 0, wPos = 0, xPos = 0; - // for (;;) - // { - // z |= ((x >>> xPos) & 1L) << zPos; - // if (++zPos == 63) - // { - // return z; - // } - // if ((xPos += 9) >= 63) - // { - // xPos = ++wPos; - // } - // } - } - - private static void Interleave2_n(long[] x, int xOff, long[] z, int zOff, int count, int rounds) - { - for (int i = 0; i < count; ++i) - { - z[zOff + i] = Interleave2_n(x[xOff + i], rounds); - } - } - - private static long Interleave2_n(long x, int rounds) - { - while (rounds > 1) - { - rounds -= 2; - x = Interleave4_16to64((int)x & 0xFFFF) - | Interleave4_16to64((int)((ulong)x >> 16) & 0xFFFF) << 1 - | Interleave4_16to64((int)((ulong)x >> 32) & 0xFFFF) << 2 - | Interleave4_16to64((int)((ulong)x >> 48) & 0xFFFF) << 3; - } - if (rounds > 0) - { - x = Interleave2_32to64((int)x) | Interleave2_32to64((int)((ulong)x >> 32)) << 1; - } - return x; - } - - private static long Interleave4_16to64(int x) - { - int r00 = INTERLEAVE4_TABLE[x & 0xFF]; - int r32 = INTERLEAVE4_TABLE[(uint)x >> 8]; - return (r32 & 0xFFFFFFFFL) << 32 | (r00 & 0xFFFFFFFFL); - } - - private static long Interleave2_32to64(int x) - { - int r00 = INTERLEAVE2_TABLE[x & 0xFF] | INTERLEAVE2_TABLE[((uint)x >> 8) & 0xFF] << 16; - int r32 = INTERLEAVE2_TABLE[((uint)x >> 16) & 0xFF] | INTERLEAVE2_TABLE[(uint)x >> 24] << 16; - return (r32 & 0xFFFFFFFFL) << 32 | (r00 & 0xFFFFFFFFL); - } - // private static LongArray ExpItohTsujii2(LongArray B, int n, int m, int[] ks) // { // LongArray t1 = B, t3 = new LongArray(new long[]{ 1L }); @@ -2074,11 +1203,11 @@ namespace Org.BouncyCastle.Math.EC // v(z) := f(z) LongArray vz = new LongArray(t); - ReduceBit(vz.m_ints, 0, m, m, ks); + ReduceBit(vz.m_data, 0, m, m, ks); // g1(z) := 1, g2(z) := 0 LongArray g1z = new LongArray(t); - g1z.m_ints[0] = 1L; + g1z.m_data[0] = 1UL; LongArray g2z = new LongArray(t); int[] uvDeg = new int[]{ uzDegree, m + 1 }; @@ -2137,7 +1266,7 @@ namespace Org.BouncyCastle.Math.EC return Equals(obj as LongArray); } - public virtual bool Equals(LongArray other) + public bool Equals(LongArray other) { if (this == other) return true; @@ -2150,7 +1279,7 @@ namespace Org.BouncyCastle.Math.EC } for (int i = 0; i < usedLen; i++) { - if (m_ints[i] != other.m_ints[i]) + if (m_data[i] != other.m_data[i]) { return false; } @@ -2164,18 +1293,18 @@ namespace Org.BouncyCastle.Math.EC int hash = 1; for (int i = 0; i < usedLen; i++) { - long mi = m_ints[i]; + ulong mi = m_data[i]; hash *= 31; hash ^= (int)mi; hash *= 31; - hash ^= (int)((ulong)mi >> 32); + hash ^= (int)(mi >> 32); } return hash; } public LongArray Copy() { - return new LongArray(Arrays.Clone(m_ints)); + return new LongArray(Arrays.Clone(m_data)); } public override string ToString() @@ -2186,16 +1315,17 @@ namespace Org.BouncyCastle.Math.EC return "0"; } - StringBuilder sb = new StringBuilder(Convert.ToString(m_ints[--i], 2)); + StringBuilder sb = new StringBuilder(i * 64); + sb.Append(Convert.ToString((long)m_data[--i], 2)); while (--i >= 0) { - string s = Convert.ToString(m_ints[i], 2); + string s = Convert.ToString((long)m_data[i], 2); // Add leading zeroes, except for highest significant word int len = s.Length; if (len < 64) { - sb.Append(ZEROES.Substring(len)); + sb.Append('0', 64 - len); } sb.Append(s); diff --git a/crypto/src/math/raw/Interleave.cs b/crypto/src/math/raw/Interleave.cs index 8e98eac32..4d866c245 100644 --- a/crypto/src/math/raw/Interleave.cs +++ b/crypto/src/math/raw/Interleave.cs @@ -8,46 +8,6 @@ namespace Org.BouncyCastle.Math.Raw private const ulong M64 = 0x5555555555555555UL; private const ulong M64R = 0xAAAAAAAAAAAAAAAAUL; - /* - * This expands 8 bit indices into 16 bit contents (high bit 14), by inserting 0s between bits. - * In a binary field, this operation is the same as squaring an 8 bit number. - */ - //private static readonly ushort[] INTERLEAVE2_TABLE = new ushort[] - //{ - // 0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015, - // 0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055, - // 0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115, - // 0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155, - // 0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415, - // 0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455, - // 0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515, - // 0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555, - // 0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015, - // 0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055, - // 0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115, - // 0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155, - // 0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415, - // 0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455, - // 0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515, - // 0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555, - // 0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015, - // 0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055, - // 0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115, - // 0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155, - // 0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415, - // 0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455, - // 0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515, - // 0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555, - // 0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015, - // 0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055, - // 0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115, - // 0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155, - // 0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415, - // 0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455, - // 0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515, - // 0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555 - //}; - internal static uint Expand8to16(uint x) { x &= 0xFFU; @@ -91,6 +51,16 @@ namespace Org.BouncyCastle.Math.Raw z[zOff + 1] = (x >> 1) & M64; } + internal static void Expand64To128(ulong[] zs, int zsOff, int zsLen) + { + int i = zsLen, zsPos = zsOff + zsLen << 1; + while (--i >= 0) + { + zsPos -= 2; + Expand64To128(zs[zsOff + i], zs, zsPos); + } + } + internal static void Expand64To128(ulong[] xs, int xsOff, int xsLen, ulong[] zs, int zsOff) { for (int i = 0; i < xsLen; ++i) @@ -109,7 +79,7 @@ namespace Org.BouncyCastle.Math.Raw x = Bits.BitPermuteStep(x, 0x0C0C0C0C0C0C0C0CUL, 2); x = Bits.BitPermuteStep(x, 0x2222222222222222UL, 1); - z[zOff] = (x ) & M64R; + z[zOff ] = (x ) & M64R; z[zOff + 1] = (x << 1) & M64R; } |