/// <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);
}
