public ECKeyGenerationParameters( DerObjectIdentifier publicKeyParamSet, SecureRandom random) : this(ECKeyParameters.LookupParameters(publicKeyParamSet), random) { this.publicKeyParamSet = publicKeyParamSet; }
public ECKeyGenerationParameters( ECDomainParameters domainParameters, SecureRandom random) : base(random, domainParameters.N.BitLength) { this.domainParams = domainParameters; }
public void Init( bool forSigning, ICipherParameters parameters) { this.forSigning = forSigning; if (forSigning) { if (parameters is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom) parameters; this.random = rParam.Random; parameters = rParam.Parameters; } else { this.random = new SecureRandom(); } if (!(parameters is ECPrivateKeyParameters)) throw new InvalidKeyException("EC private key required for signing"); this.key = (ECPrivateKeyParameters) parameters; } else { if (!(parameters is ECPublicKeyParameters)) throw new InvalidKeyException("EC public key required for verification"); this.key = (ECPublicKeyParameters) parameters; } }
public ElGamalKeyGenerationParameters( SecureRandom random, ElGamalParameters parameters) : base(random, GetStrength(parameters)) { this.parameters = parameters; }
public void Init( bool forSigning, ICipherParameters parameters) { if (forSigning) { if (parameters is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)parameters; this.random = rParam.Random; parameters = rParam.Parameters; } else { this.random = new SecureRandom(); } if (!(parameters is Gost3410PrivateKeyParameters)) throw new InvalidKeyException("GOST3410 private key required for signing"); this.key = (Gost3410PrivateKeyParameters) parameters; } else { if (!(parameters is Gost3410PublicKeyParameters)) throw new InvalidKeyException("GOST3410 public key required for signing"); this.key = (Gost3410PublicKeyParameters) parameters; } }
public Gost3410KeyGenerationParameters( SecureRandom random, Gost3410Parameters parameters) : base(random, parameters.P.BitLength - 1) { this.parameters = parameters; }
/** * initialise the ElGamal engine. * * @param forEncryption true if we are encrypting, false otherwise. * @param param the necessary ElGamal key parameters. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is ParametersWithRandom) { ParametersWithRandom p = (ParametersWithRandom) parameters; this.key = (ElGamalKeyParameters) p.Parameters; this.random = p.Random; } else { this.key = (ElGamalKeyParameters) parameters; this.random = new SecureRandom(); } this.forEncryption = forEncryption; this.bitSize = key.Parameters.P.BitLength; if (forEncryption) { if (!(key is ElGamalPublicKeyParameters)) { throw new ArgumentException("ElGamalPublicKeyParameters are required for encryption."); } } else { if (!(key is ElGamalPrivateKeyParameters)) { throw new ArgumentException("ElGamalPrivateKeyParameters are required for decryption."); } } }
public virtual void Init(bool forSigning, ICipherParameters parameters) { SecureRandom providedRandom = null; if (forSigning) { if (parameters is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)parameters; providedRandom = rParam.Random; parameters = rParam.Parameters; } if (!(parameters is ECPrivateKeyParameters)) throw new InvalidKeyException("EC private key required for signing"); this.key = (ECPrivateKeyParameters)parameters; } else { if (!(parameters is ECPublicKeyParameters)) throw new InvalidKeyException("EC public key required for verification"); this.key = (ECPublicKeyParameters)parameters; } this.random = InitSecureRandom(forSigning && !kCalculator.IsDeterministic, providedRandom); }
/** * Return a random BigInteger not less than 'min' and not greater than 'max' * * @param min the least value that may be generated * @param max the greatest value that may be generated * @param random the source of randomness * @return a random BigInteger value in the range [min,max] */ public static BigInteger CreateRandomInRange( BigInteger min, BigInteger max, // TODO Should have been just Random class SecureRandom random) { int cmp = min.CompareTo(max); if(cmp >= 0) { if(cmp > 0) throw new ArgumentException("'min' may not be greater than 'max'"); return min; } if(min.BitLength > max.BitLength / 2) { return CreateRandomInRange(BigInteger.Zero, max.Subtract(min), random).Add(min); } for(int i = 0; i < MaxIterations; ++i) { BigInteger x = new BigInteger(max.BitLength, random); if(x.CompareTo(min) >= 0 && x.CompareTo(max) <= 0) { return x; } } // fall back to a faster (restricted) method return new BigInteger(max.Subtract(min).BitLength - 1, random).Add(min); }
public void Init( ICipherParameters parameters) { AsymmetricKeyParameter kParam; if (parameters is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)parameters; this.random = rParam.Random; kParam = (AsymmetricKeyParameter)rParam.Parameters; } else { this.random = new SecureRandom(); kParam = (AsymmetricKeyParameter)parameters; } if (!(kParam is DHPrivateKeyParameters)) { throw new ArgumentException("DHEngine expects DHPrivateKeyParameters"); } this.key = (DHPrivateKeyParameters)kParam; this.dhParams = key.Parameters; }
public DsaKeyGenerationParameters( SecureRandom random, DsaParameters parameters) : base(random, parameters.P.BitLength - 1) { this.parameters = parameters; }
public Gost3410KeyGenerationParameters( SecureRandom random, DerObjectIdentifier publicKeyParamSet) : this(random, LookupParameters(publicKeyParamSet)) { this.publicKeyParamSet = publicKeyParamSet; }
public DHKeyGenerationParameters( SecureRandom random, DHParameters parameters) : base(random, GetStrength(parameters)) { this.parameters = parameters; }
/** * Parameters for generating a NaccacheStern KeyPair. * * @param random * The source of randomness * @param strength * The desired strength of the Key in Bits * @param certainty * the probability that the generated primes are not really prime * as integer: 2^(-certainty) is then the probability * @param countSmallPrimes * How many small key factors are desired */ public NaccacheSternKeyGenerationParameters( SecureRandom random, int strength, int certainty, int countSmallPrimes) : this(random, strength, certainty, countSmallPrimes, false) { }
/** * Construct for a specific usage index - this has the effect of using verifiable canonical generation of G. * * @param L desired length of prime P in bits (the effective key size). * @param N desired length of prime Q in bits. * @param certainty certainty level for prime number generation. * @param random the source of randomness to use. * @param usageIndex a valid usage index. */ public DsaParameterGenerationParameters(int L, int N, int certainty, SecureRandom random, int usageIndex) { this.l = L; this.n = N; this.certainty = certainty; this.random = random; this.usageIndex = usageIndex; }
public void Init( int size, int certainty, SecureRandom random) { this.size = size; this.certainty = certainty; this.random = random; }
/** * initialise the key generator. * * @param size size of the key * @param typeProcedure type procedure A,B = 1; A',B' - else * @param random random byte source. */ public void Init( int size, int typeProcedure, SecureRandom random) { this.size = size; this.typeproc = typeProcedure; this.init_random = random; }
public RsaKeyGenerationParameters( BigInteger publicExponent, SecureRandom random, int strength, int certainty) : base(random, strength) { this.publicExponent = publicExponent; this.certainty = certainty; }
public ParametersWithRandom( ICipherParameters parameters, SecureRandom random) { if (parameters == null) throw new ArgumentNullException("random"); if (random == null) throw new ArgumentNullException("random"); this.parameters = parameters; this.random = random; }
/** * initialise the generator with a source of randomness * and a strength (in bits). * * @param random the random byte source. * @param strength the size, in bits, of the keys we want to produce. */ public KeyGenerationParameters( SecureRandom random, int strength) { if (random == null) throw new ArgumentNullException("random"); if (strength < 1) throw new ArgumentException("strength must be a positive value", "strength"); this.random = random; this.strength = strength; }
public void Init( KeyGenerationParameters parameters) { if (parameters is ECKeyGenerationParameters) { ECKeyGenerationParameters ecP = (ECKeyGenerationParameters) parameters; this.publicKeyParamSet = ecP.PublicKeyParamSet; this.parameters = ecP.DomainParameters; } else { DerObjectIdentifier oid; switch (parameters.Strength) { case 192: oid = X9ObjectIdentifiers.Prime192v1; break; case 224: oid = SecObjectIdentifiers.SecP224r1; break; case 239: oid = X9ObjectIdentifiers.Prime239v1; break; case 256: oid = X9ObjectIdentifiers.Prime256v1; break; case 384: oid = SecObjectIdentifiers.SecP384r1; break; case 521: oid = SecObjectIdentifiers.SecP521r1; break; default: throw new InvalidParameterException("unknown key size."); } X9ECParameters ecps = FindECCurveByOid(oid); this.parameters = new ECDomainParameters( ecps.Curve, ecps.G, ecps.N, ecps.H, ecps.GetSeed()); } this.random = parameters.Random; if (this.random == null) { this.random = new SecureRandom(); } }
/** * initialise the key generator. * * @param size size of the key (range 2^512 -> 2^1024 - 64 bit increments) * @param certainty measure of robustness of prime (for FIPS 186-2 compliance this should be at least 80). * @param random random byte source. */ public virtual void Init( int size, int certainty, SecureRandom random) { if (!IsValidDsaStrength(size)) throw new ArgumentException("size must be from 512 - 1024 and a multiple of 64", "size"); this.use186_3 = false; this.L = size; this.N = GetDefaultN(size); this.certainty = certainty; this.random = random; }
private static BigInteger GeneratePrivateKey(BigInteger q, SecureRandom random) { // B.1.2 Key Pair Generation by Testing Candidates int minWeight = q.BitLength >> 2; for (;;) { // TODO Prefer this method? (change test cases that used fixed random) // B.1.1 Key Pair Generation Using Extra Random Bits //BigInteger x = new BigInteger(q.BitLength + 64, random).Mod(q.Subtract(One)).Add(One); BigInteger x = BigIntegers.CreateRandomInRange(One, q.Subtract(One), random); if (WNafUtilities.GetNafWeight(x) >= minWeight) { return x; } } }
/** * Method init * * @param forWrapping * @param param */ public void Init( bool forWrapping, ICipherParameters parameters) { this.forWrapping = forWrapping; this.engine = new CbcBlockCipher(new DesEdeEngine()); SecureRandom sr; if (parameters is ParametersWithRandom) { ParametersWithRandom pr = (ParametersWithRandom) parameters; parameters = pr.Parameters; sr = pr.Random; } else { sr = new SecureRandom(); } if (parameters is KeyParameter) { this.param = (KeyParameter) parameters; if (this.forWrapping) { // Hm, we have no IV but we want to wrap ?!? // well, then we have to create our own IV. this.iv = new byte[8]; sr.NextBytes(iv); this.paramPlusIV = new ParametersWithIV(this.param, this.iv); } } else if (parameters is ParametersWithIV) { if (!forWrapping) throw new ArgumentException("You should not supply an IV for unwrapping"); this.paramPlusIV = (ParametersWithIV) parameters; this.iv = this.paramPlusIV.GetIV(); this.param = (KeyParameter) this.paramPlusIV.Parameters; if (this.iv.Length != 8) throw new ArgumentException("IV is not 8 octets", "parameters"); } }
internal BigInteger CalculatePrivate( DHParameters dhParams, SecureRandom random) { int limit = dhParams.L; if (limit != 0) { int minWeight = limit >> 2; for (;;) { BigInteger x = new BigInteger(limit, random).SetBit(limit - 1); if (WNafUtilities.GetNafWeight(x) >= minWeight) { return x; } } } BigInteger min = BigInteger.Two; int m = dhParams.M; if (m != 0) { min = BigInteger.One.ShiftLeft(m - 1); } BigInteger q = dhParams.Q; if (q == null) { q = dhParams.P; } BigInteger max = q.Subtract(BigInteger.Two); { int minWeight = max.BitLength >> 2; for (;;) { BigInteger x = BigIntegers.CreateRandomInRange(min, max, random); if (WNafUtilities.GetNafWeight(x) >= minWeight) { return x; } } } }
public void Init( bool forEncryption, ICipherParameters param) { if (param is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)param; this.random = rParam.Random; } else { this.random = new SecureRandom(); } engine.Init(forEncryption, param); this.forEncryption = forEncryption; }
/** * Parameters for a NaccacheStern KeyPair. * * @param random * The source of randomness * @param strength * The desired strength of the Key in Bits * @param certainty * the probability that the generated primes are not really prime * as integer: 2^(-certainty) is then the probability * @param cntSmallPrimes * How many small key factors are desired * @param debug * Turn debugging on or off (reveals secret information, use with * caution) */ public NaccacheSternKeyGenerationParameters(SecureRandom random, int strength, int certainty, int countSmallPrimes, bool debug) : base(random, strength) { if (countSmallPrimes % 2 == 1) { throw new ArgumentException("countSmallPrimes must be a multiple of 2"); } if (countSmallPrimes < 30) { throw new ArgumentException("countSmallPrimes must be >= 30 for security reasons"); } this.certainty = certainty; this.countSmallPrimes = countSmallPrimes; this.debug = debug; }
/** * Initialise the factor generator * * @param param the necessary RSA key parameters. */ public void Init( ICipherParameters param) { if (param is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)param; key = (RsaKeyParameters)rParam.Parameters; random = rParam.Random; } else { key = (RsaKeyParameters)param; random = new SecureRandom(); } if (key.IsPrivate) throw new ArgumentException("generator requires RSA public key"); }
/** * initialise the RSA engine. * * @param forEncryption true if we are encrypting, false otherwise. * @param param the necessary RSA key parameters. */ public void Init( bool forEncryption, ICipherParameters param) { core.Init(forEncryption, param); if (param is ParametersWithRandom) { ParametersWithRandom rParam = (ParametersWithRandom)param; key = (RsaKeyParameters)rParam.Parameters; random = rParam.Random; } else { key = (RsaKeyParameters)param; random = new SecureRandom(); } }
/** * Initialise the key generator for DSA 2. * <p> * Use this init method if you need to generate parameters for DSA 2 keys. * </p> * * @param params DSA 2 key generation parameters. */ public virtual void Init(DsaParameterGenerationParameters parameters) { // TODO Should we enforce the minimum 'certainty' values as per C.3 Table C.1? this.use186_3 = true; this.L = parameters.L; this.N = parameters.N; this.certainty = parameters.Certainty; this.random = parameters.Random; this.usageIndex = parameters.UsageIndex; if ((L < 1024 || L > 3072) || L % 1024 != 0) throw new ArgumentException("Values must be between 1024 and 3072 and a multiple of 1024", "L"); if (L == 1024 && N != 160) throw new ArgumentException("N must be 160 for L = 1024"); if (L == 2048 && (N != 224 && N != 256)) throw new ArgumentException("N must be 224 or 256 for L = 2048"); if (L == 3072 && N != 256) throw new ArgumentException("N must be 256 for L = 3072"); if (digest.GetDigestSize() * 8 < N) throw new InvalidOperationException("Digest output size too small for value of N"); }