/// <summary> /// Generate a new set of DSA domain parameters. /// </summary> /// <returns>A new set of DSADomainParameters</returns> public DsaDomainParameters GenerateDomainParameters() { if (parameters.P != null) { byte[] seed = parameters.GetSeed(); if (seed != null && parameters.UsageIndex >= 0) { BigInteger g = DsaParametersGenerator.CalculateGenerator_FIPS186_3_Verifiable(FipsShs.CreateDigest(digestAlgorithm), parameters.P, parameters.Q, seed, parameters.UsageIndex); return(new DsaDomainParameters(parameters.P, parameters.Q, g, new Org.BouncyCastle.Crypto.Asymmetric.DsaValidationParameters(seed, -1, parameters.UsageIndex))); } else { BigInteger g = DsaParametersGenerator.CalculateGenerator_FIPS186_3_Unverifiable(parameters.P, parameters.Q, random); return(new DsaDomainParameters(parameters.P, parameters.Q, g, null)); } } else { DsaParametersGenerator pGen = new DsaParametersGenerator(FipsShs.CreateDigest(digestAlgorithm)); DsaParameterGenerationParameters dsaGenParameters = new DsaParameterGenerationParameters( parameters.L, parameters.N, parameters.Certainty, random, parameters.UsageIndex); pGen.Init(dsaGenParameters); DsaParameters p = pGen.GenerateParameters(); Org.BouncyCastle.Crypto.Internal.Parameters.DsaValidationParameters validationParameters = p.ValidationParameters; return(new DsaDomainParameters(p.P, p.Q, p.G, new Org.BouncyCastle.Crypto.Asymmetric.DsaValidationParameters(validationParameters.GetSeed(), validationParameters.Counter, validationParameters.UsageIndex))); } }
public virtual void Init(DsaParameterGenerationParameters parameters) { 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 (this.L < 1024 || this.L > 3072 || this.L % 1024 != 0) { throw new ArgumentException("Values must be between 1024 and 3072 and a multiple of 1024", "L"); } if (this.L == 1024 && this.N != 160) { throw new ArgumentException("N must be 160 for L = 1024"); } if (this.L == 2048 && this.N != 224 && this.N != 256) { throw new ArgumentException("N must be 224 or 256 for L = 2048"); } if (this.L == 3072 && this.N != 256) { throw new ArgumentException("N must be 256 for L = 3072"); } if (this.digest.GetDigestSize() * 8 < this.N) { throw new InvalidOperationException("Digest output size too small for value of N"); } }
/// <summary>Initialise the generator for DSA 2</summary> /// <remarks>You must use this Init method if you need to generate parameters for DSA 2 keys</remarks> /// <param name="parameters">An instance of <c>DsaParameterGenerationParameters</c> used to configure this generator</param> 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"); } }
public virtual void Init(DsaParameterGenerationParameters parameters) { //IL_0075: Unknown result type (might be due to invalid IL or missing references) //IL_009a: Unknown result type (might be due to invalid IL or missing references) //IL_00cc: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) //IL_0111: Unknown result type (might be due to invalid IL or missing references) use186_3 = true; L = parameters.L; N = parameters.N; certainty = parameters.Certainty; random = parameters.Random; 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"); } }
/// <summary> /// Generate a DSA2 Key pair given its bit size. /// </summary> /// <param name="keySize">"Key bit size of 1024, 2048 or 3072"</param> /// <returns>"DSA2 key pair for the given size"</returns> public AsymmetricCipherKeyPair Dsa2KeyGen(int keySize) { // Check that we got a proper key size int[] allowedKeySizes = { 1024, 2048, 3072 }; if (!(allowedKeySizes.Contains(keySize))) { throw new ArgumentException("KeySize provided is not 1024, 2048 or 3072.", "keySize"); } // Set the proper N parameter depending on the bit key size. int dsa2NParam; if (keySize == 1024) { dsa2NParam = 160; } else { dsa2NParam = 256; } var secRand = new SecureRandom(); var dsa2Genertor = GeneratorUtilities.GetKeyPairGenerator("DSA"); // Generate the proper parameters for the DSA2 Key. var digest = new Sha256Digest(); var paramGen = new DsaParametersGenerator(digest); var dsaParamsList = new DsaParameterGenerationParameters(keySize, dsa2NParam, 80, secRand); paramGen.Init(dsaParamsList); // This will take a while since it has to find a valid random prime number for use. var dsaParams = paramGen.GenerateParameters(); var dsaOptions = new DsaKeyGenerationParameters(secRand, dsaParams); var keyPair = dsa2Genertor.GenerateKeyPair(); return(keyPair); }