private void Setup() { _seed = new byte[100]; new Random().NextBytes(_seed); _parameters = NTRUParamSets.APR2011743; _gen = new IndexGenerator(_seed, _parameters); _indices = initIndices(); }
private void SetUp() { _parameters = NTRUParamSets.APR2011439FAST; _N = _parameters.N; _df1 = _parameters.DF1; _df2 = _parameters.DF2; _df3 = _parameters.DF3; _Q = _parameters.Q; _rng = new Random(); }
/// <summary> /// Constructs a new instance with a set of encryption parameters /// </summary> /// /// <param name="CipherParams">Encryption parameters</param> /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param> /// /// <exception cref="CryptoAsymmetricException">Thrown if a Prng that requires pre-initialization is specified; (wrong constructor)</exception> public NTRUKeyGenerator(NTRUParameters CipherParams, bool Parallel = true) { if (CipherParams.RandomEngine == Prngs.PBPrng) { throw new CryptoAsymmetricException("MPKCKeyGenerator:Ctor", "Passphrase based digest and CTR generators must be pre-initialized, use the other constructor!", new ArgumentException()); } this.m_frcLinear = ParallelUtils.ForceLinear; ParallelUtils.ForceLinear = !Parallel; this.m_ntruParams = CipherParams; this.m_rndEngine = this.GetPrng(this.m_ntruParams.RandomEngine); }
/// <summary> /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng /// </summary> /// /// <param name="CipherParams">The NTRUParameters instance containing the cipher settings</param> /// <param name="RngEngine">An initialized Prng instance</param> /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param> public NTRUKeyGenerator(NTRUParameters CipherParams, IRandom RngEngine, bool Parallel = true) { this.m_frcLinear = ParallelUtils.ForceLinear; // passphrase gens must be linear processed if (RngEngine.GetType().Equals(typeof(PBPRng))) { ParallelUtils.ForceLinear = true; } else { ParallelUtils.ForceLinear = !Parallel; } this.m_ntruParams = CipherParams; // set source of randomness this.m_rndEngine = RngEngine; }
private void IsValid() { // test valid key pairs NTRUParameters[] paramSets = new NTRUParameters[] { (NTRUParameters)NTRUParamSets.APR2011439.Clone(), (NTRUParameters)NTRUParamSets.APR2011439FAST.Clone(), (NTRUParameters)NTRUParamSets.APR2011743.Clone(), (NTRUParameters)NTRUParamSets.APR2011743FAST.Clone(), (NTRUParameters)NTRUParamSets.EES1087EP2.Clone(), (NTRUParameters)NTRUParamSets.EES1087EP2FAST.Clone(), (NTRUParameters)NTRUParamSets.EES1499EP1.Clone(), (NTRUParameters)NTRUParamSets.EES1499EP1FAST.Clone(), }; foreach (NTRUParameters ep in paramSets) { NTRUKeyGenerator ntru = new NTRUKeyGenerator(ep); NTRUKeyPair kp1 = (NTRUKeyPair)ntru.GenerateKeyPair(); if (!Compare.True(kp1.IsValid())) throw new Exception("NtruKeyPair generated key pair is invalid!"); } }
private void Encode(NTRUParameters param) { NTRUKeyGenerator ntru = new NTRUKeyGenerator(param); NTRUKeyPair kp = (NTRUKeyPair)ntru.GenerateKeyPair(); byte[] priv = ((NTRUPrivateKey)kp.PrivateKey).ToBytes(); byte[] pub = ((NTRUPublicKey)kp.PublicKey).ToBytes(); NTRUKeyPair kp2 = new NTRUKeyPair(new NTRUPublicKey(pub), new NTRUPrivateKey(priv)); if (!Compare.Equals(kp.PublicKey, kp2.PublicKey)) throw new Exception("EncryptionKey: public key comparison test failed!"); if (!Compare.Equals(kp.PrivateKey, kp2.PrivateKey)) throw new Exception("EncryptionKey: private key comparison test failed!"); MemoryStream bos1 = new MemoryStream(); MemoryStream bos2 = new MemoryStream(); ((NTRUPrivateKey)kp.PrivateKey).WriteTo(bos1); ((NTRUPublicKey)kp.PublicKey).WriteTo(bos2); MemoryStream bis1 = new MemoryStream(bos1.ToArray()); MemoryStream bis2 = new MemoryStream(bos2.ToArray()); NTRUKeyPair kp3 = new NTRUKeyPair(new NTRUPublicKey(bis2), new NTRUPrivateKey(bis1)); if (!Compare.Equals(kp.PublicKey, kp3.PublicKey)) throw new Exception("EncryptionKey: public key comparison test failed!"); if (!Compare.Equals(kp.PrivateKey, kp3.PrivateKey)) throw new Exception("EncryptionKey: private key comparison test failed!"); }
private void Encode() { NTRUParameters[] paramSets = new NTRUParameters[] { (NTRUParameters)NTRUParamSets.APR2011439.Clone(), (NTRUParameters)NTRUParamSets.APR2011439FAST.Clone(), (NTRUParameters)NTRUParamSets.APR2011743.Clone(), (NTRUParameters)NTRUParamSets.APR2011743FAST.Clone(), (NTRUParameters)NTRUParamSets.EES1087EP2.Clone(), (NTRUParameters)NTRUParamSets.EES1087EP2FAST.Clone(), (NTRUParameters)NTRUParamSets.EES1499EP1.Clone(), (NTRUParameters)NTRUParamSets.EES1499EP1FAST.Clone(), }; foreach (NTRUParameters param in paramSets) Encode(param); }
/// <summary> /// Constructs a new instance with a set of encryption parameters /// </summary> /// /// <param name="NtruParams">Encryption parameters</param> public NTRUEncrypt(NTRUParameters NtruParams) { _encParams = NtruParams; _dgtEngine = GetDigest(_encParams.Digest); _rndEngine = GetPrng(_encParams.RandomEngine); }
// tests a message that is too long private void TooLong(NTRUEncrypt ntru, NTRUKeyPair kp, NTRUParameters param) { byte[] plainText = new byte[param.MessageMax + 1]; try { Array.Copy(ByteUtils.GetBytes("secret encrypted text"), 0, plainText, 0, 21); ntru.Initialize(kp.PublicKey); byte[] encrypted = ntru.Encrypt(plainText); ntru.Initialize(kp); byte[] decrypted = ntru.Decrypt(encrypted); if (!Compare.AreEqual(plainText, decrypted)) throw new Exception("NtruEncryptTest: maximum length test failed!"); // should have thrown throw new Exception("NtruEncryptTest: maximum exceeded message test failed!"); } catch { } }
// encrypts and decrypts text private void TextTest(NTRUEncrypt ntru, NTRUKeyPair kp, NTRUParameters param) { byte[] plainText = ByteUtils.GetBytes("text to encrypt"); ntru.Initialize(kp.PublicKey); byte[] encrypted = ntru.Encrypt(plainText); ntru.Initialize(kp); byte[] decrypted = ntru.Decrypt(encrypted); if (!Compare.AreEqual(plainText, decrypted)) throw new Exception("NtruEncryptTest: text encryption test failed!"); }
private void GetOutputLength() { NTRUParameters[] paramSets = new NTRUParameters[] { (NTRUParameters)NTRUParamSets.APR2011439.DeepCopy(), (NTRUParameters)NTRUParamSets.APR2011439FAST.DeepCopy(), (NTRUParameters)NTRUParamSets.APR2011743.DeepCopy(), (NTRUParameters)NTRUParamSets.APR2011743FAST.DeepCopy(), (NTRUParameters)NTRUParamSets.EES1087EP2.DeepCopy(), (NTRUParameters)NTRUParamSets.EES1171EP1.DeepCopy(), (NTRUParameters)NTRUParamSets.EES1499EP1.DeepCopy(), }; byte[] plainText = ByteUtils.GetBytes("secret encrypted text"); foreach (NTRUParameters param in paramSets) { NTRUKeyPair kp; using (NTRUKeyGenerator kg = new NTRUKeyGenerator(param)) kp = (NTRUKeyPair)kg.GenerateKeyPair(); NTRUEncrypt ntru = new NTRUEncrypt(param); ntru.Initialize(kp.PublicKey); byte[] encrypted = ntru.Encrypt(plainText); if (!Compare.Equals(param.GetOutputLength(), encrypted.Length)) throw new Exception("NtruEncryptTest: output length test failed!"); } }
static double KeyGenerator(int Iterations, NTRUParameters Param) { NTRUKeyGenerator mkgen = new NTRUKeyGenerator(Param); IAsymmetricKeyPair akp; Stopwatch runTimer = new Stopwatch(); runTimer.Start(); for (int i = 0; i < Iterations; i++) akp = mkgen.GenerateKeyPair(); runTimer.Stop(); return runTimer.Elapsed.TotalMilliseconds; }
/// <summary> /// Constructs a new instance with a set of encryption parameters /// </summary> /// /// <param name="CipherParams">Encryption parameters</param> /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param> /// /// <exception cref="CryptoAsymmetricException">Thrown if a Prng that requires pre-initialization is specified; (wrong constructor)</exception> public NTRUKeyGenerator(NTRUParameters CipherParams, bool Parallel = true) { if (CipherParams.RandomEngine == Prngs.PBPrng) throw new CryptoAsymmetricException("MPKCKeyGenerator:Ctor", "Passphrase based digest and CTR generators must be pre-initialized, use the other constructor!", new ArgumentException()); _frcLinear = ParallelUtils.ForceLinear; ParallelUtils.ForceLinear = !Parallel; _ntruParams = CipherParams; _rndEngine = GetPrng(_ntruParams.RandomEngine); }
/// <summary> /// Constructs a new instance with a set of encryption parameters /// </summary> /// /// <param name="CipherParams">Encryption parameters</param> /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param> public NTRUKeyGenerator(NTRUParameters CipherParams, bool Parallel = true) { if (CipherParams.RandomEngine != Prngs.CTRPrng || CipherParams.RandomEngine != Prngs.CSPRng) _isParallel = false; else _isParallel = Parallel; _ntruParams = CipherParams; _rndEngine = GetPrng(_ntruParams.RandomEngine); }
/// <summary> /// Get a serialized NTRUParameters class from a parameter name. /// <para>Can optionally randomize Db, MinIGFHashCalls, and MinMGFHashCalls fields using the Multiplier parameters.</para> /// </summary> /// /// <param name="ParamName">The NTRU Parameters set name</param> /// /// <param name="DbMaxReductionFactor">If set between <c>0.1</c> and <c>0.4</c>, randomizes the Db field length, if <c>0.0</c> (default), returns the serialized parameter set default value. /// <para>The Db field is set to a ranged random number from the default parameter set <c>value</c> to <c>value - (value * multiplier)</c>. /// The Db field determines how many bytes of random are prepended to the message before encryption. /// Recommended range is minimum 0.1, to a maximum of 0.4.</para></param> /// /// <param name="IgfMaxAccretionFactor">If set between <c>0.1</c> and <c>0.5</c>, the MinIGFHashCalls value is randomized, if <c>0.0</c> (default), returns the parameter set default value. /// <para>The MinIGFHashCalls is set to a random value ranged between the parameter sets default <c>value</c>, up to <c>value + (value * multiplier)</c>. /// The MinIGFHashCalls value determine the number of times the hashing function is cycled during the igf polynomial generation. /// Recommended range is minimum 0.1, to a maximum of 0.2; larger values significantly impact processing times.</para></param> /// /// <param name="MgfMaxAccretionFactor">If set between <c>0.1</c> and <c>0.5</c>, the MinMGFHashCalls value is randomized, if <c>0.0</c> (default), returns the parameter set default value. /// <para>The MinMGFHashCalls is set to a random value ranged between the parameter sets default <c>value</c>, up to <c>value + (value * multiplier)</c>. /// The MinMGFHashCalls value determine the number of times the hashing function is cycled during the igf mask polynomial generation. /// Recommended range is minimum 0.1, to a maximum of 0.2; larger values significantly impact processing times.</para></param> /// /// <returns>The serialized NTRUParameters set</returns> /// /// <exception cref="CryptoAsymmetricException">Thrown if the input value is out of range</exception> public static byte[] GetFormatted(NTRUParamNames ParamName, double DbMaxReductionFactor = 0.0, double IgfMaxAccretionFactor = 0.0, double MgfMaxAccretionFactor = 0.0) { if (DbMaxReductionFactor > 0.4 || DbMaxReductionFactor < 0.0) { throw new CryptoAsymmetricException("NTRUParameters:GetFormatted", "The DbMaxReductionFactor value can not be less than 0.0 and cannot exceed 0.4!", new ArgumentOutOfRangeException()); } if (IgfMaxAccretionFactor > 0.5 || IgfMaxAccretionFactor < 0.0) { throw new CryptoAsymmetricException("NTRUParameters:GetFormatted", "The IgfMaxAccretionFactor value can not be less than 0.0 and cannot exceed 0.5!", new ArgumentOutOfRangeException()); } if (MgfMaxAccretionFactor > 0.5 || MgfMaxAccretionFactor < 0.0) { throw new CryptoAsymmetricException("NTRUParameters:GetFormatted", "The MgfMaxAccretionFactor value can not be less than 0.0 and cannot exceed 0.5!", new ArgumentOutOfRangeException()); } if (DbMaxReductionFactor == 0.0 && IgfMaxAccretionFactor == 0.0 && MgfMaxAccretionFactor == 0.0) { return(FromName(ParamName).ToBytes()); } else { NTRUParameters param = FromName(ParamName); var prng = new Prng.CSPPrng(); int diff; if (DbMaxReductionFactor > 0.0) { diff = (int)Math.Abs(param.Db * DbMaxReductionFactor); // set the db to a random in range of param value, to value - value * DbReduceMultiplier if (diff > 0) { // get a random int int pnum = prng.Next(param.Db - diff, param.Db); // round it, must be divisible by 8 param.Db = pnum - pnum % 8; } } if (IgfMaxAccretionFactor > 0.0) { // raise igf calls to default +* IgfIncreaseThreshold diff = (int)Math.Abs(param.MinIGFHashCalls * IgfMaxAccretionFactor); if (diff > 0) { param.MinIGFHashCalls = prng.Next(param.MinIGFHashCalls, param.MinIGFHashCalls + diff); } } if (MgfMaxAccretionFactor > 0.0) { // raise mgf calls to default +* MgfIncreaseThreshold diff = (int)Math.Abs(param.MinMGFHashCalls * MgfMaxAccretionFactor); if (diff > 0) { param.MinMGFHashCalls = prng.Next(param.MinMGFHashCalls, param.MinMGFHashCalls + diff); } } prng.Dispose(); return(param.ToBytes()); } }
/// <summary> /// Compare this object instance with another /// </summary> /// /// <param name="Obj">Object to compare</param> /// /// <returns>True if equal, otherwise false</returns> public override bool Equals(Object Obj) { if (this == Obj) { return(true); } if (Obj == null) { return(false); } NTRUParameters other = (NTRUParameters)Obj; if (N != other.N) { return(false); } if (BufferLenBits != other.BufferLenBits) { return(false); } if (_bufferLenTrits != other._bufferLenTrits) { return(false); } if (CBits != other.CBits) { return(false); } if (Db != other.Db) { return(false); } if (DF != other.DF) { return(false); } if (DF1 != other.DF1) { return(false); } if (DF2 != other.DF2) { return(false); } if (DF3 != other.DF3) { return(false); } if (Dg != other.Dg) { return(false); } if (Dm0 != other.Dm0) { return(false); } if (MaxM1 != other.MaxM1) { return(false); } if (DR != other.DR) { return(false); } if (DR1 != other.DR1) { return(false); } if (DR2 != other.DR2) { return(false); } if (DR3 != other.DR3) { return(false); } if (FastFp != other.FastFp) { return(false); } if (!Digest.Equals(other.Digest)) { return(false); } if (!RandomEngine.Equals(other.RandomEngine)) { return(false); } if (HashSeed != other.HashSeed) { return(false); } if (Length != other.Length) { return(false); } if (MessageMax != other.MessageMax) { return(false); } if (MinMGFHashCalls != other.MinMGFHashCalls) { return(false); } if (MinIGFHashCalls != other.MinIGFHashCalls) { return(false); } if (!Compare.AreEqual(OId, other.OId)) { return(false); } if (PkLen != other.PkLen) { return(false); } if (!PolyType.Equals(other.PolyType)) { return(false); } if (Q != other.Q) { return(false); } if (Sparse != other.Sparse) { return(false); } return(true); }
static double Encrypt(int Iterations, NTRUParameters Param) { NTRUKeyGenerator mkgen = new NTRUKeyGenerator(Param); IAsymmetricKeyPair akp = mkgen.GenerateKeyPair(); byte[] ptext = new CSPRng().GetBytes(64); byte[] ctext; Stopwatch runTimer = new Stopwatch(); using (NTRUEncrypt mpe = new NTRUEncrypt(Param)) { mpe.Initialize(akp.PublicKey); runTimer.Start(); for (int i = 0; i < Iterations; i++) ctext = mpe.Encrypt(ptext); runTimer.Stop(); } return runTimer.Elapsed.TotalMilliseconds; }
static double Decrypt(int Iterations, NTRUParameters Param) { NTRUKeyGenerator mkgen = new NTRUKeyGenerator(Param); IAsymmetricKeyPair akp = mkgen.GenerateKeyPair(); byte[] ptext = new CSPRng().GetBytes(64); byte[] rtext = new byte[64]; byte[] ctext; Stopwatch runTimer = new Stopwatch(); using (NTRUEncrypt mpe = new NTRUEncrypt(Param)) { mpe.Initialize(akp.PublicKey); ctext = mpe.Encrypt(ptext); mpe.Initialize(akp); runTimer.Start(); for (int i = 0; i < Iterations; i++) rtext = mpe.Decrypt(ctext); runTimer.Stop(); } //if (!Compare.AreEqual(ptext, rtext)) // throw new Exception("Encryption test: decryption failure!"); return runTimer.Elapsed.TotalMilliseconds; }
// params must have df1..df3 and dr1..dr3 set as well as df and dr private void EncryptDecrypt(NTRUParameters param) { NTRUKeyPair kp; using (NTRUKeyGenerator kg = new NTRUKeyGenerator(param)) kp = (NTRUKeyPair)kg.GenerateKeyPair(); NTRUEncrypt ntru = new NTRUEncrypt(param); TextTest(ntru, kp, param); // sparse/dense param.Sparse = !param.Sparse; TextTest(ntru, kp, param); param.Sparse = !param.Sparse; EmptyTest(ntru, kp, param); MaxLength(ntru, kp, param); TooLong(ntru, kp, param); kp.Dispose(); ntru.Dispose(); }
// tests a message of the maximum allowed length private void MaxLength(NTRUEncrypt ntru, NTRUKeyPair kp, NTRUParameters param) { byte[] plainText = new byte[param.MaxMsgLenBytes]; Array.Copy(ByteUtils.GetBytes("secret encrypted text"), 0, plainText, 0, 21); ntru.Initialize(kp.PublicKey); byte[] encrypted = ntru.Encrypt(plainText); ntru.Initialize(kp); byte[] decrypted = ntru.Decrypt(encrypted); if (!Compare.AreEqual(plainText, decrypted)) throw new Exception("NtruEncryptTest: maximum length test failed!"); }
/// <summary> /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng /// </summary> /// /// <param name="CipherParams">The NTRUParameters instance containing the cipher settings</param> /// <param name="RngEngine">An initialized Prng instance</param> /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param> public NTRUKeyGenerator(NTRUParameters CipherParams, IRandom RngEngine, bool Parallel = true) { _frcLinear = ParallelUtils.ForceLinear; // passphrase gens must be linear processed if (RngEngine.GetType().Equals(typeof(PBPRng))) ParallelUtils.ForceLinear = true; else ParallelUtils.ForceLinear = !Parallel; _ntruParams = CipherParams; // set source of randomness _rndEngine = RngEngine; }
/// <summary> /// Get the asymmetric parameters from a byte array /// </summary> /// /// <param name="Data">The encoded parameters</param> /// /// <returns>The asymmetric parameters</returns> private IAsymmetricParameters GetAsymmetricParams(byte[] Data) { IAsymmetricParameters param = null; try { if (Data.Length > 4) { if (Data[0] == (byte)AsymmetricEngines.McEliece) param = new MPKCParameters(Data); else if (Data[0] == (byte)AsymmetricEngines.NTRU) param = new NTRUParameters(Data); else if (Data[0] == (byte)AsymmetricEngines.RingLWE) param = new RLWEParameters(Data); } else { if (Data[0] == (byte)AsymmetricEngines.McEliece) param = MPKCParamSets.FromId(Data); else if (Data[0] == (byte)AsymmetricEngines.NTRU) param = NTRUParamSets.FromId(Data); else if (Data[0] == (byte)AsymmetricEngines.RingLWE) param = RLWEParamSets.FromId(Data); } return param; } catch (Exception ex) { throw new CryptoProcessingException("DtmKex:GetAsymmetricParams", "The param set is unknown!", ex); } }
private void Encode(NTRUParameters param) { NTRUKeyPair kp; using (NTRUKeyGenerator kg = new NTRUKeyGenerator(param, false)) kp = (NTRUKeyPair)kg.GenerateKeyPair(); // encode to byte[] and reconstruct byte[] enc = kp.ToBytes(); NTRUKeyPair kp2 = new NTRUKeyPair(enc); if (!Compare.Equals(kp, kp2)) throw new Exception("NtruKeyPair encoding test failed!"); // encode to OutputStream and reconstruct MemoryStream bos = new MemoryStream(); kp.WriteTo(bos); MemoryStream bis = new MemoryStream(bos.ToArray()); NTRUKeyPair kp3 = new NTRUKeyPair(bis); if (!Compare.Equals(kp, kp3)) throw new Exception("NtruKeyPair encoding test failed!"); }