public void Init(KeyGenerationParameters parameters) { if (parameters == null) { throw new ArgumentNullException("parameters"); } this.param = (DsaKeyGenerationParameters)parameters; }
public void Init(KeyGenerationParameters parameters) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) if (parameters == null) { throw new ArgumentNullException("parameters"); } param = (DsaKeyGenerationParameters)parameters; }
public void Init( KeyGenerationParameters parameters) { if (parameters == null) throw new ArgumentNullException("parameters"); // Note: If we start accepting instances of KeyGenerationParameters, // must apply constraint checking on strength (see DsaParametersGenerator.Init) this.param = (DsaKeyGenerationParameters) parameters; }
/// <summary> /// Create a key pair for according to the key size /// </summary> /// <param name="keySize">the key size in bits</param> public void CreateKeyPair(int keySize) { var dsaParametersGenerator = new DsaParametersGenerator(); dsaParametersGenerator.Init(keySize, 80, new SecureRandom()); var parameters = new DsaKeyGenerationParameters(new SecureRandom(), dsaParametersGenerator.GenerateParameters()); var keyGenerator = new DsaKeyPairGenerator(); keyGenerator.Init(parameters); keyPair = keyGenerator.GenerateKeyPair(); }
/// <summary> /// Generate key pair. /// </summary> /// <returns></returns> public override AsymmetricCipherKeyPair GenerateKeyPair() { DsaParametersGenerator generator2 = new DsaParametersGenerator(); generator2.Init(_keySize, _certainty, Common.ThreadSecureRandom.Value); DsaParameters parameters2 = generator2.GenerateParameters(); KeyGenerationParameters parameters = new DsaKeyGenerationParameters(Common.ThreadSecureRandom.Value, parameters2); IAsymmetricCipherKeyPairGenerator generator = new DsaKeyPairGenerator(); generator.Init(parameters); return(generator.GenerateKeyPair()); }
public AsymmetricCipherKeyPair GenerateDsaKeyPair(int keySize) { var dsaParameterGenerator = new DsaParametersGenerator(new Sha256Digest()); //Key size is fixed to be either 2048 or 3072 (Table C.1 on FIPS 186-3) dsaParameterGenerator.Init(new DsaParameterGenerationParameters(keySize, 256, 128, secureRandom.Generator)); DsaParameters dsaParameters = dsaParameterGenerator.GenerateParameters(); var keyGenerationParameters = new DsaKeyGenerationParameters(secureRandom.Generator, dsaParameters); var keyPairGenerator = new DsaKeyPairGenerator(); keyPairGenerator.Init(keyGenerationParameters); return(keyPairGenerator.GenerateKeyPair()); }
private void InitKey() { _secure_random = new SecureRandom(); DsaParametersGenerator _dsa_param_gen = new DsaParametersGenerator(); DsaKeyPairGenerator _dsa_key_pair_gen = new DsaKeyPairGenerator(); _dsa_param_gen.Init(1024, 80, _secure_random); DsaKeyGenerationParameters _dsa_key_gen_params = new DsaKeyGenerationParameters(_secure_random, _dsa_param_gen.GenerateParameters()); _dsa_key_pair_gen.Init(_dsa_key_gen_params); _key_pair = _dsa_key_pair_gen.GenerateKeyPair(); _private_key_param = (DsaPrivateKeyParameters)_key_pair.Private; _public_key_param = (DsaPublicKeyParameters)_key_pair.Public; }
//constructor /// <summary> /// A utility for easily using cryptographic functions. Automatically generates PGP and RSA keypairs. /// </summary> public CryptoHelper() { DsaKeyPairGenerator gen = new DsaKeyPairGenerator(); DsaParametersGenerator pGen = new DsaParametersGenerator(); pgpRng.SetSeed(GetRandomBytes(512)); pGen.Init(1024, 100, pgpRng); DsaKeyGenerationParameters p = new DsaKeyGenerationParameters(pgpRng, pGen.GenerateParameters()); gen.Init(p); AsymmetricCipherKeyPair keys = gen.GenerateKeyPair(); pgpPublicKey = new PgpPublicKey(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.Dsa, keys.Public, DateTime.Now); pgpPrivateKey = new PgpPrivateKey(pgpPublicKey.KeyId, pgpPublicKey.PublicKeyPacket, keys.Private); rsaPublicKey = encodeRsaPublicKey(rsa.ExportParameters(false)); rsaPrivateKey = encodeRsaPrivateKey(rsa.ExportParameters(true)); }
private void GenerateElGamal(Stream outSecret, Stream outPublic) { // Prepare a strong Secure Random with seed SecureRandom secureRandom = PgpEncryptionUtil.GetSecureRandom(); IAsymmetricCipherKeyPairGenerator dsaKpg = GeneratorUtilities.GetKeyPairGenerator("DSA"); DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init((int)PublicKeyLength.BITS_1024, 80, new SecureRandom()); // DSA is 1024 even for long 2048+ ElGamal keys DsaParameters dsaParams = pGen.GenerateParameters(); DsaKeyGenerationParameters kgp = new DsaKeyGenerationParameters(secureRandom, dsaParams); dsaKpg.Init(kgp); // // this takes a while as the key generator has to Generate some DSA parameters // before it Generates the key. // AsymmetricCipherKeyPair dsaKp = dsaKpg.GenerateKeyPair(); IAsymmetricCipherKeyPairGenerator elgKpg = GeneratorUtilities.GetKeyPairGenerator("ELGAMAL"); Group elgamalGroup = Precomputed.GetElGamalGroup((int)this.publicKeyLength); if (elgamalGroup == null) { throw new ArgumentException("ElGamal Group not found for key length: " + this.publicKeyLength); } Org.BouncyCastle.Math.BigInteger p = elgamalGroup.GetP(); Org.BouncyCastle.Math.BigInteger g = elgamalGroup.GetG(); secureRandom = PgpEncryptionUtil.GetSecureRandom(); ElGamalParameters elParams = new ElGamalParameters(p, g); ElGamalKeyGenerationParameters elKgp = new ElGamalKeyGenerationParameters(secureRandom, elParams); elgKpg.Init(elKgp); // // this is quicker because we are using preGenerated parameters. // AsymmetricCipherKeyPair elgKp = elgKpg.GenerateKeyPair(); DsaElGamalKeyGeneratorUtil.ExportKeyPair(outSecret, outPublic, dsaKp, elgKp, identity, passphrase, true); }
/// <summary> /// Construct a key pair generator for DSA keys. /// </summary> /// <param name="keyGenParameters">Domain parameters and algorithm for the generated key.</param> /// <param name="random">A source of randomness for calculating the private value.</param> internal KeyPairGenerator(KeyGenerationParameters keyGenParameters, SecureRandom random) : base(keyGenParameters) { if (CryptoServicesRegistrar.IsInApprovedOnlyMode()) { int effSizeInBits = keyGenParameters.DomainParameters.P.BitLength; if (effSizeInBits != 2048 && effSizeInBits != 3072) { throw new CryptoUnapprovedOperationError("attempt to create key pair with unapproved key size [" + effSizeInBits + "]", keyGenParameters.Algorithm); } Utils.ValidateKeyPairGenRandom(random, Utils.GetAsymmetricSecurityStrength(effSizeInBits), keyGenParameters.Algorithm); } this.domainParameters = keyGenParameters.DomainParameters; this.param = new DsaKeyGenerationParameters(random, getDomainParams(domainParameters)); this.engine.Init(param); }
/// <summary> /// DSA密钥对生成 /// </summary> /// <param name="size">size must be from 512 - 1024 and a multiple of 64</param> /// <returns></returns> public static KeyParameter Generator(int size = 1024) { var pGen = new DsaParametersGenerator(); pGen.Init(size, 80, new SecureRandom()); var dsaParams = pGen.GenerateParameters(); var kgp = new DsaKeyGenerationParameters(new SecureRandom(), dsaParams); var kpg = GeneratorUtilities.GetKeyPairGenerator("DSA"); kpg.Init(kgp); var kp = kpg.GenerateKeyPair(); var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(kp.Public); var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(kp.Private); return(new KeyParameter { PrivateKey = Base64.ToBase64String(privateKeyInfo.GetEncoded()), PublicKey = Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded()) }); }
/// <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); }
public static IAsymmetricCipherKeyPairGenerator CreateGenerator(SecureRandom random, TypeWrapper kpGen, int keystrength) { var keypairGen = kpGen.Instance <IAsymmetricCipherKeyPairGenerator>(); //var random = SecureRandomUtils.GetInstance(Model.RandomGenerator, Model.RandomGeneratorArgument); if (keypairGen is DsaKeyPairGenerator) { DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(keystrength, 80, random); //TODO: DsaParameters parameters = pGen.GenerateParameters(); DsaKeyGenerationParameters genParam = new DsaKeyGenerationParameters(random, parameters); keypairGen.Init(genParam); return(keypairGen); } if (keypairGen is ECKeyPairGenerator) { keypairGen.Init(new KeyGenerationParameters(random, keystrength)); return(keypairGen); } keypairGen.Init(new KeyGenerationParameters(random, keystrength)); return(keypairGen); }
public void CompliantParametersGenerator() { var pGen1 = new DHParametersGenerator(); pGen1.Init(2048, 10, new SecureRandom()); // Compliant var pGen2 = new DsaParametersGenerator(); pGen2.Init(2048, 80, new SecureRandom()); // Compliant var kp1 = new ECKeyPairGenerator(); // OK - ignore for now var kp2 = new DsaKeyPairGenerator(); var d2 = new DsaParameters(new BigInteger("2"), new BigInteger("2"), new BigInteger("2")); // FN var r2 = new DsaKeyGenerationParameters(new SecureRandom(), d2); kp2.Init(r2); var kp3 = new RsaKeyPairGenerator(); var r3 = new RsaKeyGenerationParameters(new BigInteger("2"), new SecureRandom(), 2048, 5); // Compliant kp3.Init(r3); }
public static int Main( string[] args) { if (args.Length < 2) { Console.WriteLine("DsaElGamalKeyRingGenerator [-a] identity passPhrase"); return(0); } IAsymmetricCipherKeyPairGenerator dsaKpg = GeneratorUtilities.GetKeyPairGenerator("DSA"); DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(1024, 80, new SecureRandom()); DsaParameters dsaParams = pGen.GenerateParameters(); DsaKeyGenerationParameters kgp = new DsaKeyGenerationParameters(new SecureRandom(), dsaParams); dsaKpg.Init(kgp); // // this takes a while as the key generator has to Generate some DSA parameters // before it Generates the key. // IAsymmetricCipherKeyPair dsaKp = dsaKpg.GenerateKeyPair(); IAsymmetricCipherKeyPairGenerator elgKpg = GeneratorUtilities.GetKeyPairGenerator("ELGAMAL"); IBigInteger g = new BigInteger("153d5d6172adb43045b68ae8e1de1070b6137005686d29d3d73a7749199681ee5b212c9b96bfdcfa5b20cd5e3fd2044895d609cf9b410b7a0f12ca1cb9a428cc", 16); IBigInteger p = new BigInteger("9494fec095f3b85ee286542b3836fc81a5dd0a0349b4c239dd38744d488cf8e31db8bcb7d33b41abb9e5a33cca9144b1cef332c94bf0573bf047a3aca98cdf3b", 16); ElGamalParameters elParams = new ElGamalParameters(p, g); ElGamalKeyGenerationParameters elKgp = new ElGamalKeyGenerationParameters(new SecureRandom(), elParams); elgKpg.Init(elKgp); // // this is quicker because we are using preGenerated parameters. // IAsymmetricCipherKeyPair elgKp = elgKpg.GenerateKeyPair(); Stream out1, out2; if (args[0].Equals("-a")) { if (args.Length < 3) { Console.WriteLine("DSAElGamalKeyRingGenerator [-a] identity passPhrase"); return(0); } out1 = File.Create("secret.asc"); out2 = File.Create("pub.asc"); ExportKeyPair(out1, out2, dsaKp, elgKp, args[1], args[2].ToCharArray(), true); } else { out1 = File.Create("secret.bpg"); out2 = File.Create("pub.bpg"); ExportKeyPair(out1, out2, dsaKp, elgKp, args[0], args[1].ToCharArray(), false); } out1.Close(); out2.Close(); return(0); }
public override void PerformTest() { byte[] k1 = Hex.Decode("d5014e4b60ef2ba8b6211b4062ba3224e0427dd3"); byte[] k2 = Hex.Decode("345e8d05c075c3a508df729a1685690e68fcfb8c8117847e89063bca1f85d968fd281540b6e13bd1af989a1fbf17e06462bf511f9d0b140fb48ac1b1baa5bded"); SecureRandom random = FixedSecureRandom.From(k1, k2); byte[] keyData = Hex.Decode("b5014e4b60ef2ba8b6211b4062ba3224e0427dd3"); SecureRandom keyRandom = FixedSecureRandom.From(keyData, keyData); BigInteger r = new BigInteger("68076202252361894315274692543577577550894681403"); BigInteger s = new BigInteger("1089214853334067536215539335472893651470583479365"); DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(512, 80, random); DsaParameters parameters = pGen.GenerateParameters(); DsaValidationParameters pValid = parameters.ValidationParameters; if (pValid.Counter != 105) { Fail("Counter wrong"); } if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { Fail("p or q wrong"); } DsaKeyPairGenerator dsaKeyGen = new DsaKeyPairGenerator(); DsaKeyGenerationParameters genParam = new DsaKeyGenerationParameters(keyRandom, parameters); dsaKeyGen.Init(genParam); AsymmetricCipherKeyPair pair = dsaKeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, keyRandom); DsaSigner dsa = new DsaSigner(); dsa.Init(true, param); byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArrayUnsigned(); BigInteger[] sig = dsa.GenerateSignature(message); if (!r.Equals(sig[0])) { Fail("r component wrong." + SimpleTest.NewLine + " expecting: " + r + SimpleTest.NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + SimpleTest.NewLine + " expecting: " + s + SimpleTest.NewLine + " got : " + sig[1]); } dsa.Init(false, pair.Public); if (!dsa.VerifySignature(message, sig[0], sig[1])) { Fail("verification fails"); } Dsa2Test1(); Dsa2Test2(); Dsa2Test3(); Dsa2Test4(); }
public static SshKey CreateKey(SshVersion version, PublicKeyAlgorithm algorithm, string comment = "") { if (version == SshVersion.SSH1 && algorithm != PublicKeyAlgorithm.SSH_RSA) { throw new Exception("unsupported version/algorithm combination"); } switch (algorithm) { case PublicKeyAlgorithm.SSH_RSA: case PublicKeyAlgorithm.SSH_RSA_CERT_V1: KeyGenerationParameters keyGenParam = new KeyGenerationParameters(secureRandom, 512); var rsaKeyPairGen = new RsaKeyPairGenerator(); rsaKeyPairGen.Init(keyGenParam); var keyPair = rsaKeyPairGen.GenerateKeyPair(); var rsaKey = new SshKey(version, keyPair, comment); return(rsaKey); case PublicKeyAlgorithm.SSH_DSS: case PublicKeyAlgorithm.SSH_DSS_CERT_V1: DsaParametersGenerator dsaParamGen = new DsaParametersGenerator(); dsaParamGen.Init(512, 10, secureRandom); DsaParameters dsaParam = dsaParamGen.GenerateParameters(); DsaKeyGenerationParameters dsaKeyGenParam = new DsaKeyGenerationParameters(secureRandom, dsaParam); DsaKeyPairGenerator dsaKeyPairGen = new DsaKeyPairGenerator(); dsaKeyPairGen.Init(dsaKeyGenParam); keyPair = dsaKeyPairGen.GenerateKeyPair(); var dsaKey = new SshKey(SshVersion.SSH2, keyPair); dsaKey.Comment = comment; return(dsaKey); case PublicKeyAlgorithm.ECDSA_SHA2_NISTP256: case PublicKeyAlgorithm.ECDSA_SHA2_NISTP256_CERT_V1: X9ECParameters ecdsa256X9Params = SecNamedCurves.GetByName("secp256r1"); ECDomainParameters ecdsa256DomainParams = new ECDomainParameters(ecdsa256X9Params.Curve, ecdsa256X9Params.G, ecdsa256X9Params.N, ecdsa256X9Params.H); ECKeyGenerationParameters ecdsa256GenParams = new ECKeyGenerationParameters(ecdsa256DomainParams, secureRandom); ECKeyPairGenerator ecdsa256Gen = new ECKeyPairGenerator(); ecdsa256Gen.Init(ecdsa256GenParams); keyPair = ecdsa256Gen.GenerateKeyPair(); var ecdsa256Key = new SshKey(SshVersion.SSH2, keyPair); ecdsa256Key.Comment = comment; return(ecdsa256Key); case PublicKeyAlgorithm.ECDSA_SHA2_NISTP384: case PublicKeyAlgorithm.ECDSA_SHA2_NISTP384_CERT_V1: X9ECParameters ecdsa384X9Params = SecNamedCurves.GetByName("secp384r1"); ECDomainParameters ecdsa384DomainParams = new ECDomainParameters(ecdsa384X9Params.Curve, ecdsa384X9Params.G, ecdsa384X9Params.N, ecdsa384X9Params.H); ECKeyGenerationParameters ecdsa384GenParams = new ECKeyGenerationParameters(ecdsa384DomainParams, secureRandom); ECKeyPairGenerator ecdsa384Gen = new ECKeyPairGenerator(); ecdsa384Gen.Init(ecdsa384GenParams); keyPair = ecdsa384Gen.GenerateKeyPair(); var ecdsa384Key = new SshKey(SshVersion.SSH2, keyPair); ecdsa384Key.Comment = comment; return(ecdsa384Key); case PublicKeyAlgorithm.ECDSA_SHA2_NISTP521: case PublicKeyAlgorithm.ECDSA_SHA2_NISTP521_CERT_V1: X9ECParameters ecdsa521X9Params = SecNamedCurves.GetByName("secp521r1"); ECDomainParameters ecdsa521DomainParams = new ECDomainParameters(ecdsa521X9Params.Curve, ecdsa521X9Params.G, ecdsa521X9Params.N, ecdsa521X9Params.H); ECKeyGenerationParameters ecdsa521GenParams = new ECKeyGenerationParameters(ecdsa521DomainParams, secureRandom); ECKeyPairGenerator ecdsa521Gen = new ECKeyPairGenerator(); ecdsa521Gen.Init(ecdsa521GenParams); keyPair = ecdsa521Gen.GenerateKeyPair(); var ecdsa521Key = new SshKey(SshVersion.SSH2, keyPair); ecdsa521Key.Comment = comment; return(ecdsa521Key); case PublicKeyAlgorithm.ED25519: case PublicKeyAlgorithm.ED25519_CERT_V1: var privateKeySeed = secureRandom.GenerateSeed(Ed25519.PrivateKeySeedSizeInBytes); var publicKeyBytes = new byte[Ed25519.PublicKeySizeInBytes]; var privateKeyBytes = new byte[Ed25519.ExpandedPrivateKeySizeInBytes]; Ed25519.KeyPairFromSeed(out publicKeyBytes, out privateKeyBytes, privateKeySeed); var publicKey = new Ed25519PublicKeyParameter(publicKeyBytes); var privateKey = new Ed25519PrivateKeyParameter(privateKeyBytes); var ed25519Key = new SshKey(SshVersion.SSH2, publicKey, privateKey, comment); return(ed25519Key); default: throw new Exception("unsupported algorithm"); } }
public override void PerformTest() { PgpPublicKey pubKey = null; // // Read the public key // PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey); pubKey = pgpPub.GetPublicKey(); // // Read the private key // PgpSecretKeyRing sKey = new PgpSecretKeyRing(testPrivKey); PgpSecretKey secretKey = sKey.GetSecretKey(); PgpPrivateKey pgpPrivKey = secretKey.ExtractPrivateKey(pass); // // test signature message // PgpObjectFactory pgpFact = new PgpObjectFactory(sig1); PgpCompressedData c1 = (PgpCompressedData)pgpFact.NextPgpObject(); pgpFact = new PgpObjectFactory(c1.GetDataStream()); PgpOnePassSignatureList p1 = (PgpOnePassSignatureList)pgpFact.NextPgpObject(); PgpOnePassSignature ops = p1[0]; PgpLiteralData p2 = (PgpLiteralData)pgpFact.NextPgpObject(); Stream dIn = p2.GetInputStream(); ops.InitVerify(pubKey); int ch; while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } PgpSignatureList p3 = (PgpSignatureList)pgpFact.NextPgpObject(); if (!ops.Verify(p3[0])) { Fail("Failed signature check"); } // // signature generation // GenerateTest(sKey, pubKey, pgpPrivKey); // // signature generation - canonical text // const string data = "hello world!"; byte[] dataBytes = Encoding.ASCII.GetBytes(data); MemoryStream bOut = new MemoryStream(); MemoryStream testIn = new MemoryStream(dataBytes, false); PgpSignatureGenerator sGen = new PgpSignatureGenerator( PublicKeyAlgorithmTag.Dsa, HashAlgorithmTag.Sha1); sGen.InitSign(PgpSignature.CanonicalTextDocument, pgpPrivKey); PgpCompressedDataGenerator cGen = new PgpCompressedDataGenerator( CompressionAlgorithmTag.Zip); BcpgOutputStream bcOut = new BcpgOutputStream(cGen.Open(new UncloseableStream(bOut))); sGen.GenerateOnePassVersion(false).Encode(bcOut); PgpLiteralDataGenerator lGen = new PgpLiteralDataGenerator(); DateTime testDateTime = new DateTime(1973, 7, 27); Stream lOut = lGen.Open( new UncloseableStream(bcOut), PgpLiteralData.Text, "_CONSOLE", dataBytes.Length, testDateTime); while ((ch = testIn.ReadByte()) >= 0) { lOut.WriteByte((byte)ch); sGen.Update((byte)ch); } lGen.Close(); sGen.Generate().Encode(bcOut); cGen.Close(); // // verify Generated signature - canconical text // pgpFact = new PgpObjectFactory(bOut.ToArray()); c1 = (PgpCompressedData)pgpFact.NextPgpObject(); pgpFact = new PgpObjectFactory(c1.GetDataStream()); p1 = (PgpOnePassSignatureList)pgpFact.NextPgpObject(); ops = p1[0]; p2 = (PgpLiteralData)pgpFact.NextPgpObject(); if (!p2.ModificationTime.Equals(testDateTime)) { Fail("Modification time not preserved"); } dIn = p2.GetInputStream(); ops.InitVerify(pubKey); while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } p3 = (PgpSignatureList)pgpFact.NextPgpObject(); if (!ops.Verify(p3[0])) { Fail("Failed generated signature check"); } // // Read the public key with user attributes // pgpPub = new PgpPublicKeyRing(testPubWithUserAttr); pubKey = pgpPub.GetPublicKey(); int count = 0; foreach (PgpUserAttributeSubpacketVector attributes in pubKey.GetUserAttributes()) { int sigCount = 0; foreach (object sigs in pubKey.GetSignaturesForUserAttribute(attributes)) { if (sigs == null) { Fail("null signature found"); } sigCount++; } if (sigCount != 1) { Fail("Failed user attributes signature check"); } count++; } if (count != 1) { Fail("Failed user attributes check"); } byte[] pgpPubBytes = pgpPub.GetEncoded(); pgpPub = new PgpPublicKeyRing(pgpPubBytes); pubKey = pgpPub.GetPublicKey(); count = 0; foreach (object ua in pubKey.GetUserAttributes()) { if (ua == null) { Fail("null user attribute found"); } count++; } if (count != 1) { Fail("Failed user attributes reread"); } // // reading test extra data - key with edge condition for DSA key password. // char[] passPhrase = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; sKey = new PgpSecretKeyRing(testPrivKey2); pgpPrivKey = sKey.GetSecretKey().ExtractPrivateKey(passPhrase); // // reading test - aes256 encrypted passphrase. // sKey = new PgpSecretKeyRing(aesSecretKey); pgpPrivKey = sKey.GetSecretKey().ExtractPrivateKey(pass); // // reading test - twofish encrypted passphrase. // sKey = new PgpSecretKeyRing(twofishSecretKey); pgpPrivKey = sKey.GetSecretKey().ExtractPrivateKey(pass); // // use of PgpKeyPair // DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(512, 80, new SecureRandom()); // TODO Is the certainty okay? DsaParameters dsaParams = pGen.GenerateParameters(); DsaKeyGenerationParameters kgp = new DsaKeyGenerationParameters(new SecureRandom(), dsaParams); IAsymmetricCipherKeyPairGenerator kpg = GeneratorUtilities.GetKeyPairGenerator("DSA"); kpg.Init(kgp); AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair(); PgpKeyPair pgpKp = new PgpKeyPair(PublicKeyAlgorithmTag.Dsa, kp.Public, kp.Private, DateTime.UtcNow); PgpPublicKey k1 = pgpKp.PublicKey; PgpPrivateKey k2 = pgpKp.PrivateKey; }