private void doSigVerifyTest( string publicKeyFile, string sigFile) { PgpPublicKeyRing publicKey = loadPublicKey(publicKeyFile); PgpObjectFactory pgpFact = loadSig(sigFile); 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(publicKey.GetPublicKey()); int ch; while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } PgpSignatureList p3 = (PgpSignatureList)pgpFact.NextPgpObject(); Assert.IsTrue(ops.Verify(p3[0])); }
internal OpenPgpDigitalCertificate(PgpPublicKeyRing keyring, PgpPublicKey pubkey) { var bytes = pubkey.GetFingerprint(); var builder = new StringBuilder(); for (int i = 0; i < bytes.Length; i++) { builder.Append(bytes[i].ToString("X2")); } // var trust = pubkey.GetTrustData (); // if (trust != null) { // TrustLevel = (TrustLevel) (trust[0] & 15); // } else { // TrustLevel = TrustLevel.None; // } Fingerprint = builder.ToString(); PublicKey = pubkey; KeyRing = keyring; if (!UpdateUserId(pubkey) && !pubkey.IsMasterKey) { foreach (PgpPublicKey key in keyring.GetPublicKeys()) { if (key.IsMasterKey) { UpdateUserId(key); break; } } } }
private void DoTestEncMessage() { PgpObjectFactory pgpFact = new PgpObjectFactory(encMessage); PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpFact.NextPgpObject(); PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; PgpPublicKey publicKey = new PgpPublicKeyRing(testPubKey).GetPublicKey(encP.KeyId); PgpSecretKey secretKey = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKeySub, false), "test".ToCharArray(), publicKey); Stream clear = encP.GetDataStream(secretKey.ExtractPrivateKey(null)); PgpObjectFactory plainFact = new PgpObjectFactory(clear); PgpCompressedData cData = (PgpCompressedData)plainFact.NextPgpObject(); PgpObjectFactory compFact = new PgpObjectFactory(cData.GetDataStream()); PgpLiteralData lData = (PgpLiteralData)compFact.NextPgpObject(); if (!"test.txt".Equals(lData.FileName)) { Fail("wrong file name detected"); } }
public static GPGKey AsciiArmored2GPGKey(string asciiArmored) { GPGKey key = null; using (var s = GenerateStreamFromString(asciiArmored)) { var pgpPub = new PgpPublicKeyRing(PgpUtilities.GetDecoderStream(s)); var pubKey = pgpPub.GetPublicKey(); key = new GPGKey { Id = null, FullFingerPrint = pubKey.GetFingerprint().ToHexString(), AsciiArmoredPublicKey = asciiArmored, AsciiArmoredPrivateKey = null, Emails = new List <string>(), Names = new List <string>(), KeyUids = new List <GPGKeyUid>(), KeyBits = pubKey.BitStrength, }; foreach (string userId in pubKey.GetUserIds()) { var m = NameObsEmailGPGReg.Match(userId); var m2 = NameEmailGPGReg.Match(userId); var email = ""; var name = ""; var obs = ""; if (m.Success && m.Groups.Count == 4) { email = m.Groups[3].Value.Trim(); obs = m.Groups[2].Value.Trim(); key.Emails.Add(email); var z = NameObsGPGReg.Match(m.Groups[1].Value); if (z.Success && z.Groups.Count == 3) { name = z.Groups[1].Value; obs = z.Groups[2].Value; key.Names.Add(name); } } else if (m2.Success && m2.Groups.Count == 3) { name = m2.Groups[1].Value; email = m2.Groups[2].Value; key.Names.Add(name); key.Emails.Add(email); } else { name = userId; key.Names.Add(name); } key.KeyUids.Add(new GPGKeyUid { Name = name, Email = email, Description = obs, }); } } return(key); }
public void SignatureGenerateAndVerify() { var pgpPub = new PgpPublicKeyRing(testPubKeyRing); var pubKey = pgpPub.GetPublicKey(); var sKey = new PgpSecretKeyRing(testPrivKeyRing); var secretKey = sKey.GetSecretKey(); var privKey = secretKey.ExtractPrivateKey(pass); // Generate signature MemoryStream bOut = new MemoryStream(); DateTime testDateTime = new DateTime(1973, 7, 27); var messageGenerator = new PgpMessageGenerator(bOut); using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip)) using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, privKey, PgpHashAlgorithm.Sha1)) using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime)) literalStream.Write(text); // Verify generated signature bOut.Position = 0; var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut); var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage(); var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage(); Assert.AreEqual(testDateTime, literalMessage.ModificationTime); literalMessage.GetStream().CopyTo(Stream.Null); Assert.IsTrue(signedMessage.Verify(pubKey)); }
public void EncryptDecryptX25519KeysTest() { PgpPublicKeyRing publicKeyRing = new PgpPublicKeyRing(testX25519PubKey); PgpSecretKeyRing secretKeyRing = new PgpSecretKeyRing(testX25519PrivKey); PgpSecretKey secretKey = secretKeyRing.GetSecretKey(0x6c37367cd2f455c5); byte[] text = Encoding.ASCII.GetBytes("hello world!"); // Encrypt text MemoryStream cbOut = new MemoryStream(); var messageGenerator = new PgpMessageGenerator(cbOut); using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5)) { encryptedGenerator.AddMethod(publicKeyRing.GetPublicKey(0x6c37367cd2f455c5)); using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Utf8, "_CONSOLE", DateTime.UtcNow)) literalStream.Write(text); } // Read it back cbOut.Position = 0; var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut); var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(secretKey.ExtractPrivateKey("test")); var bytes = Streams.ReadAll(literalMessage.GetStream()); Assert.AreEqual(text, bytes); }
public void Generate() { // Master/Signing key var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256); // Encryption key var ecdh = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP256); // Generate a key ring var passPhrase = "test"; PgpKeyRingGenerator keyRingGen = new PgpKeyRingGenerator(ecdsa, "*****@*****.**", passPhrase); keyRingGen.AddSubKey(ecdh); PgpPublicKeyRing pubRing = keyRingGen.GeneratePublicKeyRing(); // TODO: add check of KdfParameters DoBasicKeyRingCheck(pubRing); PgpSecretKeyRing secRing = keyRingGen.GenerateSecretKeyRing(); PgpPublicKeyRing pubRingEnc = new PgpPublicKeyRing(pubRing.GetEncoded()); Assert.That(pubRing.GetEncoded(), Is.EqualTo(pubRingEnc.GetEncoded()), "public key ring encoding failed"); PgpSecretKeyRing secRingEnc = new PgpSecretKeyRing(secRing.GetEncoded()); Assert.That(secRing.GetEncoded(), Is.EqualTo(secRingEnc.GetEncoded()), "secret key ring encoding failed"); PgpPrivateKey pgpPrivKey = secRing.GetSecretKey().ExtractPrivateKey(passPhrase); }
internal GenericAPI(RoamingNetwork RoamingNetwork, String HTTPServerName = DefaultHTTPServerName, IPPort HTTPServerPort = null, String URIPrefix = "", Func <String, Stream> GetRessources = null, String ServiceName = DefaultHTTPServerName, EMailAddress APIEMailAddress = null, PgpPublicKeyRing APIPublicKeyRing = null, PgpSecretKeyRing APISecretKeyRing = null, String APIPassphrase = null, EMailAddressList APIAdminEMail = null, SMTPClient APISMTPClient = null, DNSClient DNSClient = null, String LogfileName = DefaultLogfileName) : this(RoamingNetwork, new HTTPServer(DefaultServerName : DefaultHTTPServerName).AttachTCPPorts(HTTPServerPort != null ? HTTPServerPort : DefaultHTTPServerPort), URIPrefix, GetRessources, ServiceName, APIEMailAddress, APIPublicKeyRing, APISecretKeyRing, APIPassphrase, APIAdminEMail, APISMTPClient, LogfileName) { }
/// <summary> /// Initialize the OCPI HTTP server using IPAddress.Any, http port 8080 and maybe start the server. /// </summary> internal GenericAPI(RoamingNetwork RoamingNetwork, HTTPServer HTTPServer, String URIPrefix = "/ext/OCPI", Func <String, Stream> GetRessources = null, String ServiceName = DefaultHTTPServerName, EMailAddress APIEMailAddress = null, PgpPublicKeyRing APIPublicKeyRing = null, PgpSecretKeyRing APISecretKeyRing = null, String APIPassphrase = null, EMailAddressList APIAdminEMail = null, SMTPClient APISMTPClient = null, String LogfileName = DefaultLogfileName) { #region Initial checks if (RoamingNetwork == null) { throw new ArgumentNullException("RoamingNetwork", "The given parameter must not be null!"); } if (HTTPServer == null) { throw new ArgumentNullException("HTTPServer", "The given parameter must not be null!"); } if (URIPrefix.IsNullOrEmpty()) { throw new ArgumentNullException("URIPrefix", "The given parameter must not be null or empty!"); } if (!URIPrefix.StartsWith("/")) { URIPrefix = "/" + URIPrefix; } #endregion #region Init data this._HTTPServer = HTTPServer; this._GetRessources = GetRessources; this._URIPrefix = URIPrefix; this._ServiceName = ServiceName; this._APIEMailAddress = APIEMailAddress; this._APIPublicKeyRing = APIPublicKeyRing; this._APISecretKeyRing = APISecretKeyRing; this._APIPassphrase = APIPassphrase; this._APIAdminEMail = APIAdminEMail; this._APISMTPClient = APISMTPClient; this._DNSClient = HTTPServer.DNSClient; #endregion RegisterURITemplates(); }
public void ReadUserAttributes() { // // Read the public key with user attributes // var pgpPub = new PgpPublicKeyRing(testPubWithUserAttr); var pubKey = pgpPub.GetPublicKey(); int count = 0; foreach (PgpUser attributes in pubKey.GetUserAttributes()) { Assert.AreEqual(1, attributes.SelfCertifications.Count); Assert.AreEqual(0, attributes.OtherCertifications.Count); Assert.AreEqual(0, attributes.RevocationSignatures.Count); count++; } Assert.AreEqual(1, count); byte[] pgpPubBytes = pgpPub.GetEncoded(); pgpPub = new PgpPublicKeyRing(pgpPubBytes); pubKey = pgpPub.GetPublicKey(); count = 0; foreach (object ua in pubKey.GetUserAttributes()) { Assert.NotNull(ua); count++; } Assert.AreEqual(1, count); }
private void DoBasicKeyRingCheck(PgpPublicKeyRing pubKeyRing) { foreach (PgpPublicKey pubKey in pubKeyRing.GetPublicKeys()) { if (pubKey.IsMasterKey) { if (pubKey.IsEncryptionKey) { Fail("master key showed as encryption key!"); } } else { if (!pubKey.IsEncryptionKey) { Fail("sub key not encryption key!"); } foreach (PgpSignature certification in pubKeyRing.GetPublicKey().GetSignatures()) { certification.InitVerify(pubKeyRing.GetPublicKey()); if (!certification.VerifyCertification((string)First(pubKeyRing.GetPublicKey().GetUserIds()), pubKeyRing.GetPublicKey())) { Fail("subkey certification does not verify"); } } } } }
public void FingerPrintTest() { // // version 3 // PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(fingerprintKey); PgpPublicKey pubKey = pgpPub.GetPublicKey(); /*if (!AreEqual(pubKey.GetFingerprint(), Hex.Decode("4FFB9F0884266C715D1CEAC804A3BBFA"))) * { * Fail("version 3 fingerprint test failed"); * }*/ // // version 4 // pgpPub = new PgpPublicKeyRing(testPubKey); pubKey = pgpPub.GetPublicKey(); /*if (!AreEqual(pubKey.GetFingerprint(), Hex.Decode("3062363c1046a01a751946bb35586146fdf3f373"))) * { * Fail("version 4 fingerprint test failed"); * }*/ }
public void EmbeddedJpegTest() { PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey); PgpSecretKeyRing pgpSec = new PgpSecretKeyRing(testPrivKey); PgpPublicKey pubKey = pgpPub.GetPublicKey(); PgpUserAttributes vGen = new PgpUserAttributes(); vGen.JpegImageAttribute = jpegImage; var certification = PgpCertification.GenerateUserCertification( PgpSignatureType.PositiveCertification, pubKey, pgpSec.GetSecretKey().ExtractPrivateKey(pass), vGen, pubKey); PgpPublicKey nKey = PgpPublicKey.AddCertification(pubKey, vGen, certification); int count = 0; foreach (PgpUser user in nKey.GetUserAttributes()) { Assert.AreEqual(1, user.SelfCertifications.Count); Assert.IsTrue(user.SelfCertifications[0].Verify()); count++; } Assert.AreEqual(1, count); nKey = PgpPublicKey.RemoveCertification(nKey, vGen); Assert.IsFalse(nKey.GetUserAttributes().Any()); }
public void DoTestMasterKey() { PgpSecretKey key = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKeyMaster, false), "test"); PgpPublicKey publicKey = new PgpPublicKeyRing(testPubKey).GetPublicKey(); KeyTestHelper.SignAndVerifyTestMessage(key.ExtractPrivateKey(""), publicKey); }
//[TestCase("DSA-2048-224.sec", "DSA-2048-224.pub", PgpHashAlgorithm.Sha256)] //[TestCase("DSA-2048-224.sec", "DSA-2048-224.pub", PgpHashAlgorithm.Sha512)] public void GenerateTest(string privateKeyFile, string publicKeyFile, PgpHashAlgorithm digest) { PgpSecretKeyRing secRing = loadSecretKey(privateKeyFile); PgpPublicKeyRing pubRing = loadPublicKey(publicKeyFile); string data = "hello world!"; byte[] dataBytes = Encoding.ASCII.GetBytes(data); MemoryStream bOut = new MemoryStream(); DateTime testDate = new DateTime((DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond); var messageGenerator = new PgpMessageGenerator(bOut); using (var signingGenerator = messageGenerator.CreateSigned(PgpSignatureType.BinaryDocument, secRing.GetSecretKey().ExtractPrivateKey("test"), digest)) using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDate)) { literalStream.Write(dataBytes); } bOut.Position = 0; var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(bOut); Assert.AreEqual(digest, signedMessage.HashAlgorithm); Assert.AreEqual(PgpPublicKeyAlgorithm.Dsa, signedMessage.KeyAlgorithm); var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage(); Assert.AreEqual(testDate, literalMessage.ModificationTime); literalMessage.GetStream().CopyTo(Stream.Null); Assert.IsTrue(signedMessage.Verify(pubRing.GetPublicKey())); }
internal PgpKeyRingBundle(IEnumerable e) { this.secretRings = Platform.CreateHashtable(); this.pubRings = Platform.CreateHashtable(); this.order = Platform.CreateArrayList(); foreach (object obj in e) { if (obj is PgpSecretKeyRing) { PgpSecretKeyRing pgpSecret = obj as PgpSecretKeyRing; long key = pgpSecret.GetPublicKey().KeyId; secretRings.Add(key, pgpSecret); order.Add(key); } else if (obj is PgpPublicKeyRing) { PgpPublicKeyRing pgpPub = obj as PgpPublicKeyRing; long key = pgpPub.GetPublicKey().KeyId; pubRings.Add(key, pgpPub); order.Add(key); } } }
/// <summary> /// Create a new e-mail address. /// </summary> /// <param name="SimpleEMailAddressString">A string representation of a simple e-mail address.</param> /// <param name="SecretKeyRing">The secret key ring for an e-mail address.</param> /// <param name="PublicKeyRing">The public key ring for an e-mail address.</param> public EMailAddress(String SimpleEMailAddressString, PgpSecretKeyRing SecretKeyRing = null, PgpPublicKeyRing PublicKeyRing = null) : this("", SimpleEMailAddress.Parse(SimpleEMailAddressString), SecretKeyRing, PublicKeyRing) { }
/// <summary> /// Create a new e-mail address. /// </summary> /// <param name="SimpleEMailAddress">A simple e-mail address.</param> /// <param name="SecretKeyRing">The secret key ring for an e-mail address.</param> /// <param name="PublicKeyRing">The public key ring for an e-mail address.</param> public EMailAddress(SimpleEMailAddress SimpleEMailAddress, PgpSecretKeyRing SecretKeyRing = null, PgpPublicKeyRing PublicKeyRing = null) : this("", SimpleEMailAddress, SecretKeyRing, PublicKeyRing) { }
public void AddKey(string publicKey, bool nonErasable = false) { using (var s = Tools.GenerateStreamFromString(publicKey)) { var pgpPub = new PgpPublicKeyRing(PgpUtilities.GetDecoderStream(s)); var pubKey = pgpPub.GetPublicKey(); AddKey(pubKey, nonErasable); } }
public void ReferenceTest() { var pubKeyRing = new PgpPublicKeyRing(referencePubKey); var publicKey = pubKeyRing.GetPublicKey(); var signature = new PgpSignature(referenceSignature); Assert.IsTrue(signature.Verify(publicKey, new MemoryStream(Encoding.ASCII.GetBytes(referenceMessage), false)), "signature failed to verify!"); }
private void Generate() { SecureRandom random = SecureRandom.GetInstance("SHA1PRNG"); // // Generate a master key // IAsymmetricCipherKeyPairGenerator keyGen = GeneratorUtilities.GetKeyPairGenerator("ECDSA"); keyGen.Init(new ECKeyGenerationParameters(SecObjectIdentifiers.SecP256r1, random)); AsymmetricCipherKeyPair kpSign = keyGen.GenerateKeyPair(); PgpKeyPair ecdsaKeyPair = new PgpKeyPair(PublicKeyAlgorithmTag.ECDsa, kpSign, DateTime.UtcNow); // // Generate an encryption key // keyGen = GeneratorUtilities.GetKeyPairGenerator("ECDH"); keyGen.Init(new ECKeyGenerationParameters(SecObjectIdentifiers.SecP256r1, random)); AsymmetricCipherKeyPair kpEnc = keyGen.GenerateKeyPair(); PgpKeyPair ecdhKeyPair = new PgpKeyPair(PublicKeyAlgorithmTag.ECDH, kpEnc, DateTime.UtcNow); // // Generate a key ring // char[] passPhrase = "test".ToCharArray(); PgpKeyRingGenerator keyRingGen = new PgpKeyRingGenerator(PgpSignature.PositiveCertification, ecdsaKeyPair, "*****@*****.**", SymmetricKeyAlgorithmTag.Aes256, passPhrase, true, null, null, random); keyRingGen.AddSubKey(ecdhKeyPair); PgpPublicKeyRing pubRing = keyRingGen.GeneratePublicKeyRing(); // TODO: add check of KdfParameters DoBasicKeyRingCheck(pubRing); PgpSecretKeyRing secRing = keyRingGen.GenerateSecretKeyRing(); PgpPublicKeyRing pubRingEnc = new PgpPublicKeyRing(pubRing.GetEncoded()); if (!Arrays.AreEqual(pubRing.GetEncoded(), pubRingEnc.GetEncoded())) { Fail("public key ring encoding failed"); } PgpSecretKeyRing secRingEnc = new PgpSecretKeyRing(secRing.GetEncoded()); if (!Arrays.AreEqual(secRing.GetEncoded(), secRingEnc.GetEncoded())) { Fail("secret key ring encoding failed"); } PgpPrivateKey pgpPrivKey = secRing.GetSecretKey().ExtractPrivateKey(passPhrase); }
/// <summary> /// Imports a public pgp keyring. /// </summary> /// <remarks> /// Imports a public pgp keyring. /// </remarks> /// <param name="keyring">The pgp keyring.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="keyring"/> is <c>null</c>. /// </exception> public virtual void Import(PgpPublicKeyRing keyring) { if (keyring == null) { throw new ArgumentNullException(nameof(keyring)); } PublicKeyRingBundle = PgpPublicKeyRingBundle.AddPublicKeyRing(PublicKeyRingBundle, keyring); SavePublicKeyRingBundle(); }
public static byte[] ToAsc(byte[] pgp) { MemoryStream ms = new MemoryStream(); var ring = new PgpPublicKeyRing(GetStream(pgp)); var armored = new ArmoredOutputStream(ms); ring.Encode(armored); armored.Dispose(); return(ms.ToArray()); }
public static void GenerateKeyPair(string userid, string password, out PgpPublicKeyRing pkr, out PgpSecretKeyRing skr) { PgpKeyRingGenerator krgen = PGP.generateKeyRingGenerator(userid, password); // Generate public key ring, dump to file. pkr = krgen.GeneratePublicKeyRing(); // Generate private key, dump to file. skr = krgen.GenerateSecretKeyRing(); }
//[TestCase("DSA-7680-384.pub", "dsa-7680-384-sign.gpg")] //[TestCase("DSA-15360-512.pub", "dsa-15360-512-sign.gpg")] public void SignatureVerifyTest(string publicKeyFile, string sigFile) { PgpPublicKeyRing publicKey = loadPublicKey(publicKeyFile); var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(loadSig(sigFile)); var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage(); var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage(); literalMessage.GetStream().CopyTo(Stream.Null); Assert.IsTrue(signedMessage.Verify(publicKey.GetPublicKey())); }
/// <summary> /// Create a new e-mail address. /// </summary> /// <param name="OwnerName">The name of the owner of the e-mail address.</param> /// <param name="SimpleEMailAddress">A simple e-mail address.</param> /// <param name="SecretKeyRing">The secret key ring for an e-mail address.</param> /// <param name="PublicKeyRing">The public key ring for an e-mail address.</param> public EMailAddress(String OwnerName, SimpleEMailAddress SimpleEMailAddress, PgpSecretKeyRing SecretKeyRing = null, PgpPublicKeyRing PublicKeyRing = null) { this._OwnerName = OwnerName.Trim(); this._Address = SimpleEMailAddress; this._PublicKeyRing = PublicKeyRing; this._SecretKeyRing = SecretKeyRing; }
public static PgpSecretKeyRing ReplacePublicKeys(PgpSecretKeyRing secretRing, PgpPublicKeyRing publicRing) { IList list = Platform.CreateArrayList(secretRing.keys.Count); foreach (PgpSecretKey key in secretRing.keys) { PgpPublicKey publicKey = publicRing.GetPublicKey(key.KeyId); list.Add(PgpSecretKey.ReplacePublicKey(key, publicKey)); } return(new PgpSecretKeyRing(list)); }
public void Encode(Stream outStr) { BcpgOutputStream outStr2 = BcpgOutputStream.Wrap(outStr); foreach (object item in order) { long num = (long)item; PgpPublicKeyRing pgpPublicKeyRing = (PgpPublicKeyRing)pubRings[num]; pgpPublicKeyRing.Encode(outStr2); } }
/// <summary> /// Returns public key from armored ASCII key content. /// </summary> /// <param name="key">Armored text format containing key.</param> /// <returns></returns> public static PgpPublicKey GetPublicKeyFromAsciiArmored(string key) { using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(key))) { using (var armored = new ArmoredInputStream(memStream)) { var result = new PgpPublicKeyRing(armored); return(result.GetPublicKey()); } } }
public static void p5_crypto_pgp_keys_create(ApplicationContext context, ActiveEventArgs e) { // Making sure we clean up after ourselves. using (new ArgsRemover(e.Args, true)) { // Retrieving identity (normally a name + email address), in addition to password. string identity = e.Args.GetExChildValue <string> ("identity", context); string password = e.Args.GetExChildValue <string> ("password", context); if (string.IsNullOrEmpty(identity) || string.IsNullOrEmpty(password)) { throw new LambdaException( "Minimum [identity] and [password] needs to be supplied to create a PGP keypair", e.Args, context); } // Retrieving other parameters to PGP keypair creation, giving them sane defaults if not supplied. DateTime expires = e.Args.GetExChildValue("expires", context, DateTime.Now.AddYears(3)); int strength = e.Args.GetExChildValue <int> ("strength", context, 4096); long publicExponent = e.Args.GetExChildValue("public-exponent", context, 65537L); int certainty = e.Args.GetExChildValue("certainty", context, 5); // Creating our key generator. PgpKeyRingGenerator generator = GetKeyRingGenerator( context, identity, password, expires, strength, publicExponent, certainty); // Generating public keyrign. PgpPublicKeyRing publicRing = generator.GeneratePublicKeyRing(); // Generating secret keyring. "Secret key" is BC's name for private key. PgpSecretKeyRing secretRing = generator.GenerateSecretKeyRing(); /* * Retrieving PGP context to let MimeKit import keys into PGP storage. * Making sure we retrieve it in "write mode". */ using (var ctx = context.RaiseEvent(".p5.crypto.pgp-keys.context.create", new Node("", true)).Get <OpenPgpContext> (context)) { // Saves public keyring. ctx.Import(publicRing); // Saves secret keyring (private key, BC uses different naming convention). ctx.Import(secretRing); } // Returning fingerprint and key-id to caller. e.Args.Add("fingerprint", Fingerprint.FingerprintString(publicRing.GetPublicKey().GetFingerprint())); e.Args.Add("key-id", ((int)publicRing.GetPublicKey().KeyId).ToString("X")); } }
private void DoTestMasterKey() { PgpSecretKey key = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKeyMaster, false), "test".ToCharArray()); byte[] msg = Encoding.UTF8.GetBytes("hello world!"); PgpSignatureGenerator signGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.ECDsa, HashAlgorithmTag.Sha256); signGen.InitSign(PgpSignature.BinaryDocument, key.ExtractPrivateKey(null)); signGen.Update(msg); PgpSignature sig = signGen.Generate(); PgpPublicKey publicKey = new PgpPublicKeyRing(testPubKey).GetPublicKey(); sig.InitVerify(publicKey); sig.Update(msg); if (!sig.Verify()) { Fail("signature failed to verify!"); } }
public override void PerformTest() { // // Read the public key // PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey); AsymmetricKeyParameter pubKey = pgpPub.GetPublicKey().GetKey(); IEnumerator enumerator = pgpPub.GetPublicKey().GetUserIds().GetEnumerator(); enumerator.MoveNext(); string uid = (string) enumerator.Current; enumerator = pgpPub.GetPublicKey().GetSignaturesForId(uid).GetEnumerator(); enumerator.MoveNext(); PgpSignature sig = (PgpSignature) enumerator.Current; sig.InitVerify(pgpPub.GetPublicKey()); if (!sig.VerifyCertification(uid, pgpPub.GetPublicKey())) { Fail("failed to verify certification"); } // // write a public key // MemoryStream bOut = new UncloseableMemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pgpPub.Encode(pOut); if (!Arrays.AreEqual(bOut.ToArray(), testPubKey)) { Fail("public key rewrite failed"); } // // Read the public key // PgpPublicKeyRing pgpPubV3 = new PgpPublicKeyRing(testPubKeyV3); AsymmetricKeyParameter pubKeyV3 = pgpPub.GetPublicKey().GetKey(); // // write a V3 public key // bOut = new UncloseableMemoryStream(); pOut = new BcpgOutputStream(bOut); pgpPubV3.Encode(pOut); // // Read a v3 private key // char[] passP = "FIXCITY_QA".ToCharArray(); { PgpSecretKeyRing pgpPriv2 = new PgpSecretKeyRing(testPrivKeyV3); PgpSecretKey pgpPrivSecretKey = pgpPriv2.GetSecretKey(); PgpPrivateKey pgpPrivKey2 = pgpPrivSecretKey.ExtractPrivateKey(passP); // // write a v3 private key // bOut = new UncloseableMemoryStream(); pOut = new BcpgOutputStream(bOut); pgpPriv2.Encode(pOut); byte[] result = bOut.ToArray(); if (!Arrays.AreEqual(result, testPrivKeyV3)) { Fail("private key V3 rewrite failed"); } } // // Read the private key // PgpSecretKeyRing pgpPriv = new PgpSecretKeyRing(testPrivKey); PgpPrivateKey pgpPrivKey = pgpPriv.GetSecretKey().ExtractPrivateKey(pass); // // write a private key // bOut = new UncloseableMemoryStream(); pOut = new BcpgOutputStream(bOut); pgpPriv.Encode(pOut); if (!Arrays.AreEqual(bOut.ToArray(), testPrivKey)) { Fail("private key rewrite failed"); } // // test encryption // IBufferedCipher c = CipherUtilities.GetCipher("RSA"); // c.Init(Cipher.ENCRYPT_MODE, pubKey); c.Init(true, pubKey); byte[] inBytes = Encoding.ASCII.GetBytes("hello world"); byte[] outBytes = c.DoFinal(inBytes); // c.Init(Cipher.DECRYPT_MODE, pgpPrivKey.GetKey()); c.Init(false, pgpPrivKey.Key); outBytes = c.DoFinal(outBytes); if (!Arrays.AreEqual(inBytes, outBytes)) { Fail("decryption failed."); } // // 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(pgpPub.GetPublicKey(ops.KeyId)); 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"); } // // encrypted message - read subkey // pgpPriv = new PgpSecretKeyRing(subKey); // // encrypted message // byte[] text = Encoding.ASCII.GetBytes("hello world!\n"); PgpObjectFactory pgpF = new PgpObjectFactory(enc1); PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; pgpPrivKey = pgpPriv.GetSecretKey(encP.KeyId).ExtractPrivateKey(pass); Stream clear = encP.GetDataStream(pgpPrivKey); pgpFact = new PgpObjectFactory(clear); c1 = (PgpCompressedData)pgpFact.NextPgpObject(); pgpFact = new PgpObjectFactory(c1.GetDataStream()); PgpLiteralData ld = (PgpLiteralData)pgpFact.NextPgpObject(); if (!ld.FileName.Equals("test.txt")) { throw new Exception("wrong filename in packet"); } Stream inLd = ld.GetDataStream(); byte[] bytes = Streams.ReadAll(inLd); if (!Arrays.AreEqual(bytes, text)) { Fail("wrong plain text in decrypted packet"); } // // encrypt - short message // byte[] shortText = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' }; MemoryStream cbOut = new UncloseableMemoryStream(); PgpEncryptedDataGenerator cPk = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Cast5, new SecureRandom()); PgpPublicKey puK = pgpPriv.GetSecretKey(encP.KeyId).PublicKey; cPk.AddMethod(puK); Stream cOut = cPk.Open(new UncloseableStream(cbOut), shortText.Length); cOut.Write(shortText, 0, shortText.Length); cOut.Close(); pgpF = new PgpObjectFactory(cbOut.ToArray()); encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); encP = (PgpPublicKeyEncryptedData)encList[0]; pgpPrivKey = pgpPriv.GetSecretKey(encP.KeyId).ExtractPrivateKey(pass); if (encP.GetSymmetricAlgorithm(pgpPrivKey) != SymmetricKeyAlgorithmTag.Cast5) { Fail("symmetric algorithm mismatch"); } clear = encP.GetDataStream(pgpPrivKey); outBytes = Streams.ReadAll(clear); if (!Arrays.AreEqual(outBytes, shortText)) { Fail("wrong plain text in generated short text packet"); } // // encrypt // cbOut = new UncloseableMemoryStream(); cPk = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Cast5, new SecureRandom()); puK = pgpPriv.GetSecretKey(encP.KeyId).PublicKey; cPk.AddMethod(puK); cOut = cPk.Open(new UncloseableStream(cbOut), text.Length); cOut.Write(text, 0, text.Length); cOut.Close(); pgpF = new PgpObjectFactory(cbOut.ToArray()); encList = (PgpEncryptedDataList)pgpF.NextPgpObject(); encP = (PgpPublicKeyEncryptedData)encList[0]; pgpPrivKey = pgpPriv.GetSecretKey(encP.KeyId).ExtractPrivateKey(pass); clear = encP.GetDataStream(pgpPrivKey); outBytes = Streams.ReadAll(clear); if (!Arrays.AreEqual(outBytes, text)) { Fail("wrong plain text in generated packet"); } // // read public key with sub key. // pgpF = new PgpObjectFactory(subPubKey); object o; while ((o = pgpFact.NextPgpObject()) != null) { // TODO Should something be tested here? // Console.WriteLine(o); } // // key pair generation - CAST5 encryption // char[] passPhrase = "hello".ToCharArray(); IAsymmetricCipherKeyPairGenerator kpg = GeneratorUtilities.GetKeyPairGenerator("RSA"); RsaKeyGenerationParameters genParam = new RsaKeyGenerationParameters( BigInteger.ValueOf(0x10001), new SecureRandom(), 1024, 25); kpg.Init(genParam); AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair(); PgpSecretKey secretKey = new PgpSecretKey( PgpSignature.DefaultCertification, PublicKeyAlgorithmTag.RsaGeneral, kp.Public, kp.Private, DateTime.UtcNow, "fred", SymmetricKeyAlgorithmTag.Cast5, passPhrase, null, null, new SecureRandom() ); PgpPublicKey key = secretKey.PublicKey; enumerator = key.GetUserIds().GetEnumerator(); enumerator.MoveNext(); uid = (string) enumerator.Current; enumerator = key.GetSignaturesForId(uid).GetEnumerator(); enumerator.MoveNext(); sig = (PgpSignature) enumerator.Current; sig.InitVerify(key); if (!sig.VerifyCertification(uid, key)) { Fail("failed to verify certification"); } pgpPrivKey = secretKey.ExtractPrivateKey(passPhrase); key = PgpPublicKey.RemoveCertification(key, uid, sig); if (key == null) { Fail("failed certification removal"); } byte[] keyEnc = key.GetEncoded(); key = PgpPublicKey.AddCertification(key, uid, sig); keyEnc = key.GetEncoded(); PgpSignatureGenerator sGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.RsaGeneral, HashAlgorithmTag.Sha1); sGen.InitSign(PgpSignature.KeyRevocation, secretKey.ExtractPrivateKey(passPhrase)); sig = sGen.GenerateCertification(key); key = PgpPublicKey.AddCertification(key, sig); keyEnc = key.GetEncoded(); PgpPublicKeyRing tmpRing = new PgpPublicKeyRing(keyEnc); key = tmpRing.GetPublicKey(); IEnumerator sgEnum = key.GetSignaturesOfType(PgpSignature.KeyRevocation).GetEnumerator(); sgEnum.MoveNext(); sig = (PgpSignature) sgEnum.Current; sig.InitVerify(key); if (!sig.VerifyCertification(key)) { Fail("failed to verify revocation certification"); } // // use of PgpKeyPair // PgpKeyPair pgpKp = new PgpKeyPair(PublicKeyAlgorithmTag.RsaGeneral, kp.Public, kp.Private, DateTime.UtcNow); PgpPublicKey k1 = pgpKp.PublicKey; PgpPrivateKey k2 = pgpKp.PrivateKey; k1.GetEncoded(); MixedTest(k2, k1); // // key pair generation - AES_256 encryption. // kp = kpg.GenerateKeyPair(); secretKey = new PgpSecretKey(PgpSignature.DefaultCertification, PublicKeyAlgorithmTag.RsaGeneral, kp.Public, kp.Private, DateTime.UtcNow, "fred", SymmetricKeyAlgorithmTag.Aes256, passPhrase, null, null, new SecureRandom()); secretKey.ExtractPrivateKey(passPhrase); secretKey.Encode(new UncloseableMemoryStream()); // // secret key password changing. // const string newPass = "******"; secretKey = PgpSecretKey.CopyWithNewPassword(secretKey, passPhrase, newPass.ToCharArray(), secretKey.KeyEncryptionAlgorithm, new SecureRandom()); secretKey.ExtractPrivateKey(newPass.ToCharArray()); secretKey.Encode(new UncloseableMemoryStream()); key = secretKey.PublicKey; key.Encode(new UncloseableMemoryStream()); enumerator = key.GetUserIds().GetEnumerator(); enumerator.MoveNext(); uid = (string) enumerator.Current; enumerator = key.GetSignaturesForId(uid).GetEnumerator(); enumerator.MoveNext(); sig = (PgpSignature) enumerator.Current; sig.InitVerify(key); if (!sig.VerifyCertification(uid, key)) { Fail("failed to verify certification"); } pgpPrivKey = secretKey.ExtractPrivateKey(newPass.ToCharArray()); // // signature generation // const string data = "hello world!"; byte[] dataBytes = Encoding.ASCII.GetBytes(data); bOut = new UncloseableMemoryStream(); MemoryStream testIn = new MemoryStream(dataBytes, false); sGen = new PgpSignatureGenerator( PublicKeyAlgorithmTag.RsaGeneral, HashAlgorithmTag.Sha1); sGen.InitSign(PgpSignature.BinaryDocument, 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.Binary, "_CONSOLE", dataBytes.Length, testDateTime); // TODO Need a stream object to automatically call Update? // (via ISigner implementation of PgpSignatureGenerator) while ((ch = testIn.ReadByte()) >= 0) { lOut.WriteByte((byte)ch); sGen.Update((byte)ch); } lOut.Close(); sGen.Generate().Encode(bcOut); bcOut.Close(); // // verify generated signature // 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(secretKey.PublicKey); // TODO Need a stream object to automatically call Update? // (via ISigner implementation of PgpSignatureGenerator) while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } p3 = (PgpSignatureList)pgpFact.NextPgpObject(); if (!ops.Verify(p3[0])) { Fail("Failed generated signature check"); } // // signature generation - version 3 // bOut = new UncloseableMemoryStream(); testIn = new MemoryStream(dataBytes); PgpV3SignatureGenerator sGenV3 = new PgpV3SignatureGenerator( PublicKeyAlgorithmTag.RsaGeneral, HashAlgorithmTag.Sha1); sGen.InitSign(PgpSignature.BinaryDocument, pgpPrivKey); cGen = new PgpCompressedDataGenerator(CompressionAlgorithmTag.Zip); bcOut = new BcpgOutputStream(cGen.Open(new UncloseableStream(bOut))); sGen.GenerateOnePassVersion(false).Encode(bcOut); lGen = new PgpLiteralDataGenerator(); lOut = lGen.Open( new UncloseableStream(bcOut), PgpLiteralData.Binary, "_CONSOLE", dataBytes.Length, testDateTime); // TODO Need a stream object to automatically call Update? // (via ISigner implementation of PgpSignatureGenerator) while ((ch = testIn.ReadByte()) >= 0) { lOut.WriteByte((byte) ch); sGen.Update((byte)ch); } lOut.Close(); sGen.Generate().Encode(bcOut); bcOut.Close(); // // verify generated signature // 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(secretKey.PublicKey); // TODO Need a stream object to automatically call Update? // (via ISigner implementation of PgpSignatureGenerator) while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } p3 = (PgpSignatureList)pgpFact.NextPgpObject(); if (!ops.Verify(p3[0])) { Fail("Failed v3 generated signature check"); } // // extract PGP 8 private key // pgpPriv = new PgpSecretKeyRing(pgp8Key); secretKey = pgpPriv.GetSecretKey(); pgpPrivKey = secretKey.ExtractPrivateKey(pgp8Pass); // // other sig tests // PerformTestSig(HashAlgorithmTag.Sha256, secretKey.PublicKey, pgpPrivKey); PerformTestSig(HashAlgorithmTag.Sha384, secretKey.PublicKey, pgpPrivKey); PerformTestSig(HashAlgorithmTag.Sha512, secretKey.PublicKey, pgpPrivKey); FingerPrintTest(); ExistingEmbeddedJpegTest(); EmbeddedJpegTest(); }
public override void PerformTest() { // // Read the public key // PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey); var pubKey = pgpPub.GetPublicKey(); // // Read the private key // PgpSecretKeyRing sKey = new PgpSecretKeyRing(testPrivKey); IPgpSecretKey secretKey = sKey.GetSecretKey(); IPgpPrivateKey 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); IAsymmetricCipherKeyPair kp = kpg.GenerateKeyPair(); PgpKeyPair pgpKp = new PgpKeyPair(PublicKeyAlgorithmTag.Dsa, kp.Public, kp.Private, DateTime.UtcNow); PgpPublicKey k1 = pgpKp.PublicKey; PgpPrivateKey k2 = pgpKp.PrivateKey; }
private void checkPublicKeyRingWithX509( byte[] keyRing) { PgpPublicKeyRing pubRing = new PgpPublicKeyRing(keyRing); IEnumerator en = pubRing.GetPublicKeys().GetEnumerator(); if (en.MoveNext()) { PgpPublicKey key = (PgpPublicKey) en.Current; IEnumerator sEn = key.GetSignatures().GetEnumerator(); if (sEn.MoveNext()) { PgpSignature sig = (PgpSignature) sEn.Current; if (sig.KeyAlgorithm != PublicKeyAlgorithmTag.Experimental_1) { Fail("experimental signature not found"); } if (!AreEqual(sig.GetSignature(), Hex.Decode("000101"))) { Fail("experimental encoding check failed"); } } else { Fail("no signature found"); } } else { Fail("no key found"); } }
public void PublicKeyRingWithX509Test() { checkPublicKeyRingWithX509(pubWithX509); PgpPublicKeyRing pubRing = new PgpPublicKeyRing(pubWithX509); checkPublicKeyRingWithX509(pubRing.GetEncoded()); }
public void PerformTest8() { PgpPublicKeyRingBundle pubRings = new PgpPublicKeyRingBundle(pub8); int count = 0; byte[] encRing = pubRings.GetEncoded(); pubRings = new PgpPublicKeyRingBundle(encRing); foreach (PgpPublicKeyRing pgpPub1 in pubRings.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpPub1.GetEncoded(); PgpPublicKeyRing pgpPub2 = new PgpPublicKeyRing(bytes); foreach (PgpPublicKey o in pgpPub2.GetPublicKeys()) { if (o == null) Fail("null key found"); keyCount++; } if (keyCount != 2) { Fail("wrong number of public keys"); } } if (count != 2) { Fail("wrong number of public keyrings"); } PgpSecretKeyRingBundle secretRings1 = new PgpSecretKeyRingBundle(sec8); count = 0; encRing = secretRings1.GetEncoded(); PgpSecretKeyRingBundle secretRings2 = new PgpSecretKeyRingBundle(encRing); foreach (PgpSecretKeyRing pgpSec1 in secretRings1.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpSec1.GetEncoded(); PgpSecretKeyRing pgpSec2 = new PgpSecretKeyRing(bytes); foreach (PgpSecretKey k in pgpSec2.GetSecretKeys()) { keyCount++; k.ExtractPrivateKey(sec8pass); } if (keyCount != 2) { Fail("wrong number of secret keys"); } } if (count != 1) { Fail("wrong number of secret keyrings"); } }
public void PerformTest7() { PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(pub7); PgpPublicKey masterKey = null; foreach (PgpPublicKey k in pgpPub.GetPublicKeys()) { if (k.IsMasterKey) { masterKey = k; continue; } int count = 0; PgpSignature sig = null; foreach (PgpSignature sigTemp in k.GetSignaturesOfType(PgpSignature.SubkeyRevocation)) { sig = sigTemp; count++; } if (count != 1) { Fail("wrong number of revocations in test7."); } sig.InitVerify(masterKey); if (!sig.VerifyCertification(k)) { Fail("failed to verify revocation certification"); } } }
private void EmbeddedJpegTest() { PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey); PgpSecretKeyRing pgpSec = new PgpSecretKeyRing(testPrivKey); PgpPublicKey pubKey = pgpPub.GetPublicKey(); PgpUserAttributeSubpacketVectorGenerator vGen = new PgpUserAttributeSubpacketVectorGenerator(); vGen.SetImageAttribute(ImageAttrib.Format.Jpeg, jpegImage); PgpUserAttributeSubpacketVector uVec = vGen.Generate(); PgpSignatureGenerator sGen = new PgpSignatureGenerator( PublicKeyAlgorithmTag.RsaGeneral, HashAlgorithmTag.Sha1); sGen.InitSign(PgpSignature.PositiveCertification, pgpSec.GetSecretKey().ExtractPrivateKey(pass)); PgpSignature sig = sGen.GenerateCertification(uVec, pubKey); PgpPublicKey nKey = PgpPublicKey.AddCertification(pubKey, uVec, sig); int count = 0; foreach (PgpUserAttributeSubpacketVector attributes in nKey.GetUserAttributes()) { int sigCount = 0; foreach (PgpSignature s in nKey.GetSignaturesForUserAttribute(attributes)) { s.InitVerify(pubKey); if (!s.VerifyCertification(attributes, pubKey)) { Fail("added signature failed verification"); } sigCount++; } if (sigCount != 1) { Fail("Failed added user attributes signature check"); } count++; } if (count != 1) { Fail("didn't find added user attributes"); } nKey = PgpPublicKey.RemoveCertification(nKey, uVec); if (nKey.GetUserAttributes().GetEnumerator().MoveNext()) { Fail("found attributes where none expected"); } }
public void TestRevocation() { PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(pub7); PgpPublicKey masterKey = null; foreach (PgpPublicKey k in pgpPub.GetPublicKeys()) { if (k.IsMasterKey) { masterKey = k; } } int count = 0; PgpSignature sig = null; foreach (PgpSignature pgpSig in masterKey.GetSignaturesOfType(PgpSignature.KeyRevocation)) { sig = pgpSig; ++count; } if (count != 1) { Fail("wrong number of revocations in test7."); } sig.InitVerify(masterKey); if (!sig.VerifyCertification(masterKey)) { Fail("failed to verify revocation certification"); } pgpPub = new PgpPublicKeyRing(pub7sub); masterKey = null; foreach (PgpPublicKey k in pgpPub.GetPublicKeys()) { if (k.IsMasterKey) { masterKey = k; continue; } count = 0; sig = null; foreach (PgpSignature pgpSig in k.GetSignaturesOfType(PgpSignature.SubkeyRevocation)) { sig = pgpSig; ++count; } if (count != 1) { Fail("wrong number of revocations in test7 subkey."); } if (sig.SignatureType != PgpSignature.SubkeyRevocation) { Fail("wrong signature found"); } sig.InitVerify(masterKey); if (!sig.VerifyCertification(masterKey, k)) { Fail("failed to verify revocation certification of subkey"); } } }
private void LongSubPacketsTest() { Stream fIn = SimpleTest.GetTestDataAsStream("openpgp.longSigSubPack.asc"); Stream bIn = new BufferedStream(fIn); PgpPublicKeyRing pkr = new PgpPublicKeyRing(PgpUtilities.GetDecoderStream(bIn)); bIn.Close(); PgpPublicKey masterpk = pkr.GetPublicKey(); // Check userids foreach (string uid in masterpk.GetUserIds()) { CheckUidSig(masterpk, uid); } }
private void FingerPrintTest() { // // version 3 // PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(fingerprintKey); PgpPublicKey pubKey = pgpPub.GetPublicKey(); if (!Arrays.AreEqual(pubKey.GetFingerprint(), Hex.Decode("4FFB9F0884266C715D1CEAC804A3BBFA"))) { Fail("version 3 fingerprint test failed"); } // // version 4 // pgpPub = new PgpPublicKeyRing(testPubKey); pubKey = pgpPub.GetPublicKey(); if (!Arrays.AreEqual(pubKey.GetFingerprint(), Hex.Decode("3062363c1046a01a751946bb35586146fdf3f373"))) { Fail("version 4 fingerprint test failed"); } }
public override void PerformTest() { // // Read the public key // PgpPublicKeyRing pubKeyRing = new PgpPublicKeyRing(testPubKey); foreach (PgpSignature certification in pubKeyRing.GetPublicKey().GetSignatures()) { certification.InitVerify(pubKeyRing.GetPublicKey()); if (!certification.VerifyCertification((string)First(pubKeyRing.GetPublicKey().GetUserIds()), pubKeyRing.GetPublicKey())) { Fail("self certification does not verify"); } } if (pubKeyRing.GetPublicKey().BitStrength != 256) { Fail("incorrect bit strength returned"); } // // Read the private key // PgpSecretKeyRing secretKeyRing = new PgpSecretKeyRing(testPrivKey); PgpPrivateKey privKey = secretKeyRing.GetSecretKey().ExtractPrivateKey(testPasswd); GenerateAndSign(); // // sExpr // byte[] msg = Encoding.ASCII.GetBytes("hello world!"); PgpSecretKey key = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKey, false), "test".ToCharArray()); PgpSignatureGenerator signGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.ECDsa, HashAlgorithmTag.Sha256); signGen.InitSign(PgpSignature.BinaryDocument, key.ExtractPrivateKey(null)); signGen.Update(msg); PgpSignature sig = signGen.Generate(); sig.InitVerify(key.PublicKey); sig.Update(msg); if (!sig.Verify()) { Fail("signature failed to verify!"); } }
public override void PerformTest() { // // Read the public key // PgpPublicKeyRing pubKeyRing = new PgpPublicKeyRing(testPubKey); DoBasicKeyRingCheck(pubKeyRing); // // Read the private key // PgpSecretKeyRing secretKeyRing = new PgpSecretKeyRing(testPrivKey); TestDecrypt(secretKeyRing); EncryptDecryptTest(); Generate(); }
public void PublicKeyRingWithX509Test() { CheckPublicKeyRingWithX509(_pubWithX509); var pubRing = new PgpPublicKeyRing(_pubWithX509); CheckPublicKeyRingWithX509(pubRing.GetEncoded()); }
private void GenerateAndSign() { SecureRandom random = SecureRandom.GetInstance("SHA1PRNG"); IAsymmetricCipherKeyPairGenerator keyGen = GeneratorUtilities.GetKeyPairGenerator("ECDSA"); keyGen.Init(new ECKeyGenerationParameters(SecObjectIdentifiers.SecP256r1, random)); AsymmetricCipherKeyPair kpSign = keyGen.GenerateKeyPair(); PgpKeyPair ecdsaKeyPair = new PgpKeyPair(PublicKeyAlgorithmTag.ECDsa, kpSign, DateTime.UtcNow); byte[] msg = Encoding.ASCII.GetBytes("hello world!"); // // try a signature // PgpSignatureGenerator signGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.ECDsa, HashAlgorithmTag.Sha256); signGen.InitSign(PgpSignature.BinaryDocument, ecdsaKeyPair.PrivateKey); signGen.Update(msg); PgpSignature sig = signGen.Generate(); sig.InitVerify(ecdsaKeyPair.PublicKey); sig.Update(msg); if (!sig.Verify()) { Fail("signature failed to verify!"); } // // generate a key ring // char[] passPhrase = "test".ToCharArray(); PgpKeyRingGenerator keyRingGen = new PgpKeyRingGenerator(PgpSignature.PositiveCertification, ecdsaKeyPair, "*****@*****.**", SymmetricKeyAlgorithmTag.Aes256, passPhrase, true, null, null, random); PgpPublicKeyRing pubRing = keyRingGen.GeneratePublicKeyRing(); PgpSecretKeyRing secRing = keyRingGen.GenerateSecretKeyRing(); PgpPublicKeyRing pubRingEnc = new PgpPublicKeyRing(pubRing.GetEncoded()); if (!Arrays.AreEqual(pubRing.GetEncoded(), pubRingEnc.GetEncoded())) { Fail("public key ring encoding failed"); } PgpSecretKeyRing secRingEnc = new PgpSecretKeyRing(secRing.GetEncoded()); if (!Arrays.AreEqual(secRing.GetEncoded(), secRingEnc.GetEncoded())) { Fail("secret key ring encoding failed"); } // // try a signature using encoded key // signGen = new PgpSignatureGenerator(PublicKeyAlgorithmTag.ECDsa, HashAlgorithmTag.Sha256); signGen.InitSign(PgpSignature.BinaryDocument, secRing.GetSecretKey().ExtractPrivateKey(passPhrase)); signGen.Update(msg); sig = signGen.Generate(); sig.InitVerify(secRing.GetSecretKey().PublicKey); sig.Update(msg); if (!sig.Verify()) { Fail("re-encoded signature failed to verify!"); } }
private void DoTestSignedEncMessage() { PgpObjectFactory pgpFact = new PgpObjectFactory(signedEncMessage); PgpEncryptedDataList encList = (PgpEncryptedDataList)pgpFact.NextPgpObject(); PgpPublicKeyEncryptedData encP = (PgpPublicKeyEncryptedData)encList[0]; PgpPublicKeyRing publicKeyRing = new PgpPublicKeyRing(testPubKey); PgpPublicKey publicKey = publicKeyRing.GetPublicKey(encP.KeyId); PgpSecretKey secretKey = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKeySub, false), "test".ToCharArray(), publicKey); Stream clear = encP.GetDataStream(secretKey.ExtractPrivateKey(null)); PgpObjectFactory plainFact = new PgpObjectFactory(clear); PgpCompressedData cData = (PgpCompressedData)plainFact.NextPgpObject(); PgpObjectFactory compFact = new PgpObjectFactory(cData.GetDataStream()); PgpOnePassSignatureList sList = (PgpOnePassSignatureList)compFact.NextPgpObject(); PgpOnePassSignature ops = sList[0]; PgpLiteralData lData = (PgpLiteralData)compFact.NextPgpObject(); if (!"test.txt".Equals(lData.FileName)) { Fail("wrong file name detected"); } Stream dIn = lData .GetInputStream(); ops.InitVerify(publicKeyRing.GetPublicKey(ops.KeyId)); int ch; while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); } PgpSignatureList p3 = (PgpSignatureList)compFact.NextPgpObject(); if (!ops.Verify(p3[0])) { Fail("Failed signature check"); } }
public void PerformTest1() { PgpPublicKeyRingBundle pubRings = new PgpPublicKeyRingBundle(pub1); int count = 0; foreach (PgpPublicKeyRing pgpPub1 in pubRings.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpPub1.GetEncoded(); PgpPublicKeyRing pgpPub2 = new PgpPublicKeyRing(bytes); foreach (PgpPublicKey pubKey in pgpPub2.GetPublicKeys()) { keyCount++; foreach (PgpSignature sig in pubKey.GetSignatures()) { if (sig == null) Fail("null signature found"); } } if (keyCount != 2) { Fail("wrong number of public keys"); } } if (count != 1) { Fail("wrong number of public keyrings"); } // // exact match // count = 0; foreach (PgpPublicKeyRing pgpPub3 in pubRings.GetKeyRings("test (Test key) <*****@*****.**>")) { if (pgpPub3 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of public keyrings on exact match"); } // // partial match 1 expected // count = 0; foreach (PgpPublicKeyRing pgpPub4 in pubRings.GetKeyRings("test", true)) { if (pgpPub4 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of public keyrings on partial match 1"); } // // partial match 0 expected // count = 0; foreach (PgpPublicKeyRing pgpPub5 in pubRings.GetKeyRings("XXX", true)) { if (pgpPub5 == null) Fail("null keyring found"); count++; } if (count != 0) { Fail("wrong number of public keyrings on partial match 0"); } // // case-insensitive partial match // count = 0; foreach (PgpPublicKeyRing pgpPub6 in pubRings.GetKeyRings("*****@*****.**", true, true)) { if (pgpPub6 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of public keyrings on case-insensitive partial match"); } PgpSecretKeyRingBundle secretRings = new PgpSecretKeyRingBundle(sec1); count = 0; foreach (PgpSecretKeyRing pgpSec1 in secretRings.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpSec1.GetEncoded(); PgpSecretKeyRing pgpSec2 = new PgpSecretKeyRing(bytes); foreach (PgpSecretKey k in pgpSec2.GetSecretKeys()) { keyCount++; PgpPublicKey pk = k.PublicKey; pk.GetSignatures(); byte[] pkBytes = pk.GetEncoded(); PgpPublicKeyRing pkR = new PgpPublicKeyRing(pkBytes); } if (keyCount != 2) { Fail("wrong number of secret keys"); } } if (count != 1) { Fail("wrong number of secret keyrings"); } // // exact match // count = 0; foreach (PgpSecretKeyRing o1 in secretRings.GetKeyRings("test (Test key) <*****@*****.**>")) { if (o1 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of secret keyrings on exact match"); } // // partial match 1 expected // count = 0; foreach (PgpSecretKeyRing o2 in secretRings.GetKeyRings("test", true)) { if (o2 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of secret keyrings on partial match 1"); } // // exact match 0 expected // count = 0; foreach (PgpSecretKeyRing o3 in secretRings.GetKeyRings("test", false)) { if (o3 == null) Fail("null keyring found"); count++; } if (count != 0) { Fail("wrong number of secret keyrings on partial match 0"); } // // case-insensitive partial match // count = 0; foreach (PgpSecretKeyRing o4 in secretRings.GetKeyRings("*****@*****.**", true, true)) { if (o4 == null) Fail("null keyring found"); count++; } if (count != 1) { Fail("wrong number of secret keyrings on case-insensitive partial match"); } }
public void PerformTest10() { PgpSecretKeyRing secretRing = new PgpSecretKeyRing(sec10); foreach (PgpSecretKey secretKey in secretRing.GetSecretKeys()) { PgpPublicKey pubKey = secretKey.PublicKey; if (pubKey.ValidDays != 28) { Fail("days wrong on secret key ring"); } if (pubKey.GetValidSeconds() != 28 * 24 * 60 * 60) { Fail("seconds wrong on secret key ring"); } } PgpPublicKeyRing publicRing = new PgpPublicKeyRing(pub10); foreach (PgpPublicKey pubKey in publicRing.GetPublicKeys()) { if (pubKey.ValidDays != 28) { Fail("days wrong on public key ring"); } if (pubKey.GetValidSeconds() != 28 * 24 * 60 * 60) { Fail("seconds wrong on public key ring"); } } }
public static void Main(string[] args) { if (args.Length == 1) { Stream fis = File.OpenRead(args[0]); var ring = new PgpPublicKeyRing( PgpUtilities.GetDecoderStream(fis)); var key = ring.GetPublicKey(); // iterate through all direct key signautures and look for NotationData subpackets foreach (PgpSignature sig in key.GetSignaturesOfType(PgpSignature.DirectKey)) { Console.WriteLine("Signature date is: " + sig.GetHashedSubPackets().GetSignatureCreationTime()); var data = sig.GetHashedSubPackets().GetNotationDataOccurences(); for (int i = 0; i < data.Length; i++) { Console.WriteLine("Found Notaion named '" + data[i].GetNotationName() +"' with content '" + data[i].GetNotationValue() + "'."); } } fis.Close(); } else if (args.Length == 5) { Stream secFis = File.OpenRead(args[0]); Stream pubFis = File.OpenRead(args[2]); // gather command line arguments PgpSecretKeyRing secRing = new PgpSecretKeyRing( PgpUtilities.GetDecoderStream(secFis)); String secretKeyPass = args[1]; PgpPublicKeyRing ring = new PgpPublicKeyRing( PgpUtilities.GetDecoderStream(pubFis)); String notationName = args[3]; String notationValue = args[4]; // create the signed keyRing PgpPublicKeyRing sRing = null; sRing = new PgpPublicKeyRing( new MemoryStream( SignPublicKey(secRing.GetSecretKey(), secretKeyPass, ring.GetPublicKey(), notationName, notationValue, true), false)); ring = sRing; secFis.Close(); pubFis.Close(); Stream fos = File.Create("SignedKey.asc"); // write the created keyRing to file ArmoredOutputStream aOut = new ArmoredOutputStream(fos); sRing.Encode(aOut); aOut.Close(); // Note: ArmoredOutputStream.Close() leaves underlying stream open fos.Close(); } else { Console.Error.WriteLine("usage: DirectKeySignature secretKeyFile secretKeyPass publicKeyFile(key to be signed) NotationName NotationValue"); Console.Error.WriteLine("or: DirectKeySignature signedPublicKeyFile"); } }
public void PerformTest11() { PgpPublicKeyRing pubRing = new PgpPublicKeyRing(subKeyBindingKey); foreach (PgpPublicKey key in pubRing.GetPublicKeys()) { if (key.GetValidSeconds() != 0) { Fail("expiration time non-zero"); } } }
private void CheckEccKey(IPgpSecretKeyRing secretKeyRing) { var keyCount = 0; var bytes = secretKeyRing.GetEncoded(); var pgpSec2 = new PgpSecretKeyRing(bytes); foreach (PgpSecretKey k in pgpSec2.GetSecretKeys()) { keyCount++; var pk = k.PublicKey; pk.GetSignatures(); var pkBytes = pk.GetEncoded(); var pkR1 = new PgpPublicKeyRing(pkBytes); Assert.IsNotNull(pkR1); var pk1 = pkR1.GetPublicKey(); AreEqual(pk1.GetFingerprint(), pk.GetFingerprint()); var pkBytes1 = pkR1.GetEncoded(); var pkR2 = new PgpPublicKeyRing(pkBytes1); Assert.IsNotNull(pkR2); var pkBytes2 = pkR2.GetEncoded(); AreEqual(pkBytes1, pkBytes2); } if (keyCount != secretKeyRing.SecretKeyCount) { Fail("wrong number of secret keys"); } }
public void PerformTest2() { PgpPublicKeyRingBundle pubRings = new PgpPublicKeyRingBundle(pub2); int count = 0; byte[] encRing = pubRings.GetEncoded(); pubRings = new PgpPublicKeyRingBundle(encRing); foreach (PgpPublicKeyRing pgpPub1 in pubRings.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpPub1.GetEncoded(); PgpPublicKeyRing pgpPub2 = new PgpPublicKeyRing(bytes); foreach (PgpPublicKey pk in pgpPub2.GetPublicKeys()) { byte[] pkBytes = pk.GetEncoded(); PgpPublicKeyRing pkR = new PgpPublicKeyRing(pkBytes); keyCount++; } if (keyCount != 2) { Fail("wrong number of public keys"); } } if (count != 2) { Fail("wrong number of public keyrings"); } PgpSecretKeyRingBundle secretRings2 = new PgpSecretKeyRingBundle(sec2); count = 0; encRing = secretRings2.GetEncoded(); PgpSecretKeyRingBundle secretRings = new PgpSecretKeyRingBundle(encRing); foreach (PgpSecretKeyRing pgpSec1 in secretRings2.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpSec1.GetEncoded(); PgpSecretKeyRing pgpSec2 = new PgpSecretKeyRing(bytes); foreach (PgpSecretKey k in pgpSec2.GetSecretKeys()) { keyCount++; PgpPublicKey pk = k.PublicKey; if (pk.KeyId == -1413891222336124627L) { int sCount = 0; foreach (PgpSignature pgpSignature in pk.GetSignaturesOfType(PgpSignature.SubkeyBinding)) { int type = pgpSignature.SignatureType; if (type != PgpSignature.SubkeyBinding) { Fail("failed to return correct signature type"); } sCount++; } if (sCount != 1) { Fail("failed to find binding signature"); } } pk.GetSignatures(); if (k.KeyId == -4049084404703773049L || k.KeyId == -1413891222336124627L) { k.ExtractPrivateKey(sec2pass1); } else if (k.KeyId == -6498553574938125416L || k.KeyId == 59034765524361024L) { k.ExtractPrivateKey(sec2pass2); } } if (keyCount != 2) { Fail("wrong number of secret keys"); } } if (count != 2) { Fail("wrong number of secret keyrings"); } }
public void PerformTest3() { PgpPublicKeyRingBundle pubRings = new PgpPublicKeyRingBundle(pub3); int count = 0; byte[] encRing = pubRings.GetEncoded(); pubRings = new PgpPublicKeyRingBundle(encRing); foreach (PgpPublicKeyRing pgpPub1 in pubRings.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpPub1.GetEncoded(); PgpPublicKeyRing pgpPub2 = new PgpPublicKeyRing(bytes); foreach (PgpPublicKey pubK in pgpPub2.GetPublicKeys()) { keyCount++; pubK.GetSignatures(); } if (keyCount != 2) { Fail("wrong number of public keys"); } } if (count != 1) { Fail("wrong number of public keyrings"); } PgpSecretKeyRingBundle secretRings2 = new PgpSecretKeyRingBundle(sec3); count = 0; encRing = secretRings2.GetEncoded(); PgpSecretKeyRingBundle secretRings = new PgpSecretKeyRingBundle(encRing); foreach (PgpSecretKeyRing pgpSec1 in secretRings2.GetKeyRings()) { count++; int keyCount = 0; byte[] bytes = pgpSec1.GetEncoded(); PgpSecretKeyRing pgpSec2 = new PgpSecretKeyRing(bytes); foreach (PgpSecretKey k in pgpSec2.GetSecretKeys()) { keyCount++; k.ExtractPrivateKey(sec3pass1); } if (keyCount != 2) { Fail("wrong number of secret keys"); } } if (count != 1) { Fail("wrong number of secret keyrings"); } }
private void ExistingEmbeddedJpegTest() { PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(embeddedJPEGKey); PgpPublicKey pubKey = pgpPub.GetPublicKey(); int count = 0; foreach (PgpUserAttributeSubpacketVector attributes in pubKey.GetUserAttributes()) { int sigCount = 0; foreach (PgpSignature sig in pubKey.GetSignaturesForUserAttribute(attributes)) { sig.InitVerify(pubKey); if (!sig.VerifyCertification(attributes, pubKey)) { Fail("signature failed verification"); } sigCount++; } if (sigCount != 1) { Fail("Failed user attributes signature check"); } count++; } if (count != 1) { Fail("didn't find user attributes"); } }