static double Decrypt(int Iterations, MPKCParameters Param)
{
MPKCKeyGenerator mkgen = new MPKCKeyGenerator(Param);
IAsymmetricKeyPair akp = mkgen.GenerateKeyPair();
byte[] ptext = new CSPRng().GetBytes(64);
byte[] rtext = new byte[64];
byte[] ctext;
Stopwatch runTimer = new Stopwatch();
using (MPKCEncrypt mpe = new MPKCEncrypt(Param))
{
mpe.Initialize(akp.PublicKey);
ctext = mpe.Encrypt(ptext);
mpe.Initialize(akp.PrivateKey);
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;
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CiphersParams">The MPKCParameters instance containing thecipher settings</param>
public MPKCKeyGenerator(MPKCParameters CiphersParams)
{
_mpkcParams = (MPKCParameters)CiphersParams;
// set source of randomness
_rndEngine = GetPrng(_mpkcParams.RandomEngine);
_M = _mpkcParams.M;
_N = _mpkcParams.N;
_T = _mpkcParams.T;
_fieldPoly = _mpkcParams.FieldPolynomial;
}
/// <summary>
/// Get the cipher engine
/// </summary>
///
/// <param name="CipherParams">The cipher parameters</param>
///
/// <returns>An initialized cipher</returns>
private IMPKCCiphers GetEngine(MPKCParameters CipherParams)
{
switch (CipherParams.CCA2Engine)
{
case CCA2Ciphers.KobaraImai:
return(new KobaraImaiCipher(CipherParams));
case CCA2Ciphers.Pointcheval:
return(new PointchevalCipher(CipherParams));
default:
return(new FujisakiCipher(CipherParams));
}
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The MPKCParameters instance containing thecipher settings</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 MPKCKeyGenerator(MPKCParameters 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;
_mpkcParams = (MPKCParameters)CipherParams;
// set source of randomness
_rndEngine = GetPrng(_mpkcParams.RandomEngine);
_M = _mpkcParams.M;
_N = _mpkcParams.N;
_T = _mpkcParams.T;
_fieldPoly = _mpkcParams.FieldPolynomial;
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The MPKCParameters instance containing thecipher settings</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 MPKCKeyGenerator(MPKCParameters 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;
_mpkcParams = (MPKCParameters)CipherParams;
// set source of randomness
_rndEngine = GetPrng(_mpkcParams.RandomEngine);
_M = _mpkcParams.M;
_N = _mpkcParams.N;
_T = _mpkcParams.T;
_fieldPoly = _mpkcParams.FieldPolynomial;
}
/// <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 && this != null)
{
return(false);
}
MPKCParameters other = (MPKCParameters)Obj;
if (Digest != other.Digest)
{
return(false);
}
if (CCA2Engine != other.CCA2Engine)
{
return(false);
}
if (RandomEngine != other.RandomEngine)
{
return(false);
}
if (M != other.M)
{
return(false);
}
if (N != other.N)
{
return(false);
}
if (T != other.T)
{
return(false);
}
if (FieldPolynomial != other.FieldPolynomial)
{
return(false);
}
return(true);
}
static double Encrypt(int Iterations, MPKCParameters Param)
{
MPKCKeyGenerator mkgen = new MPKCKeyGenerator(Param);
IAsymmetricKeyPair akp = mkgen.GenerateKeyPair();
byte[] ptext = new CSPRng().GetBytes(64);
byte[] ctext;
Stopwatch runTimer = new Stopwatch();
using (MPKCEncrypt mpe = new MPKCEncrypt(Param))
{
mpe.Initialize(akp.PublicKey);
runTimer.Start();
for (int i = 0; i < Iterations; i++)
ctext = mpe.Encrypt(ptext);
runTimer.Stop();
}
return runTimer.Elapsed.TotalMilliseconds;
}
/// <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 RLWEParameters 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 MPKCKeyGenerator(MPKCParameters CipherParams, IRandom RngEngine, bool Parallel = true)
{
_mpkcParams = (MPKCParameters)CipherParams;
// set source of randomness
_rndEngine = RngEngine;
_M = _mpkcParams.M;
_N = _mpkcParams.N;
_T = _mpkcParams.T;
_fieldPoly = _mpkcParams.FieldPolynomial;
_frcLinear = ParallelUtils.ForceLinear;
// passphrase gens must be linear processed
if (RngEngine.GetType().Equals(typeof(PBPRng)))
{
ParallelUtils.ForceLinear = true;
}
else
{
ParallelUtils.ForceLinear = !Parallel;
}
}
/// <summary>
/// Get the cipher engine
/// </summary>
///
/// <param name="CipherParams">The engine type</param>
///
/// <returns>An initialized cipher</returns>
private IMPKCCiphers GetEngine(MPKCParameters CipherParams)
{
switch (CipherParams.CCA2Engine)
{
case CCA2Ciphers.KobaraImai:
return new KobaraImaiCipher(CipherParams);
case CCA2Ciphers.Pointcheval:
return new PointchevalCipher(CipherParams);
default:
return new FujisakiCipher(CipherParams);
}
}
static double KeyGenerator(int Iterations, MPKCParameters Param)
{
MPKCKeyGenerator mkgen = new MPKCKeyGenerator(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>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The cipher engine</param>
public MPKCEncrypt(MPKCParameters CipherParams)
{
_encEngine = GetEngine(CipherParams);
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The cipher engine</param>
public MPKCEncrypt(MPKCParameters CipherParams)
{
m_encEngine = GetEngine(CipherParams);
}
private void Dispose(bool Disposing)
{
if (!_isDisposed && Disposing)
{
try
{
if (_mpkcParams != null)
{
_mpkcParams.Dispose();
_mpkcParams = null;
}
if (_rndEngine != null)
{
_rndEngine.Dispose();
_rndEngine = null;
}
_M = 0;
_N = 0;
_T = 0;
_fieldPoly = 0;
}
catch { }
_isDisposed = true;
}
}
/// <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 RLWEParameters 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 MPKCKeyGenerator(MPKCParameters CipherParams, IRandom RngEngine, bool Parallel = true)
{
_mpkcParams = (MPKCParameters)CipherParams;
// set source of randomness
_rndEngine = RngEngine;
_M = _mpkcParams.M;
_N = _mpkcParams.N;
_T = _mpkcParams.T;
_fieldPoly = _mpkcParams.FieldPolynomial;
_frcLinear = ParallelUtils.ForceLinear;
// passphrase gens must be linear processed
if (RngEngine.GetType().Equals(typeof(PBPRng)))
ParallelUtils.ForceLinear = true;
else
ParallelUtils.ForceLinear = !Parallel;
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The McEliece cipher used to encrypt the hash</param>
/// <param name="Digest">The type of digest engine used</param>
public MPKCSign(MPKCParameters CipherParams, Digests Digest = Digests.SHA512)
{
_dgtEngine = GetDigest(CipherParams.Digest);
_asyCipher = GetEngine(CipherParams);
}
/// <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);
}
}
/// <summary>
/// Initialize this class
/// </summary>
///
/// <param name="CipherParams">The McEliece cipher used to encrypt the hash</param>
/// <param name="Digest">The type of digest engine used</param>
public MPKCSign(MPKCParameters CipherParams, Digests Digest = Digests.SHA512)
{
m_dgtEngine = GetDigest(CipherParams.Digest);
m_asyCipher = GetEngine(CipherParams);
}
