private PgpSecretKey GetLastSecretKey(PgpSecretKeyRingBundle secret_key_ring_bundle) { IEnumerable pgpKeyRings = secret_key_ring_bundle.GetKeyRings(); return((from PgpSecretKeyRing kring in secret_key_ring_bundle.GetKeyRings() select kring.GetSecretKeys().Cast <PgpSecretKey>(). LastOrDefault(k => k.IsSigningKey)).LastOrDefault(key => key != null)); }
/// <summary> /// Reads secret key from given privateKey /// </summary> /// <param name="privateKeyFile">Path to private key file</param> /// <returns>PgpSecretKey of the given privateKey</returns> internal static PgpSecretKey ReadSecretKey(string privateKeyFile) { PgpSecretKey secretKey = null; using (Stream secretKeyStream = File.OpenRead(privateKeyFile)) { var secretKeyRingBundle = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(secretKeyStream)); foreach (PgpSecretKeyRing keyRing in secretKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { secretKey = key; } } } if (secretKey == null) { throw new Exception("Wrong private key - Can't find signing key in key ring."); } } return(secretKey); }
private PgpSecretKey GetsecretKeyByUserId(PgpSecretKeyRingBundle secretKeyRingBundle, String secretKeyUserId) { foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) { PgpSecretKey key = kRing.GetSecretKeys() .Cast <PgpSecretKey>() .Where(k => k.IsSigningKey) .FirstOrDefault(); if (key != null) { foreach (String userId in key.UserIds) { if (userId.Contains(secretKeyUserId)) { return(key); } } } } return(null); }
private PgpSecretKey readSecretKey(Stream privateKeyStream) { PgpSecretKeyRingBundle pgpSec; try { pgpSec = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(privateKeyStream)); } catch (Exception e) { throw new Exception("Invalid private key stream, reason: " + e.Message); } var keyRings = pgpSec.GetKeyRings(); foreach (PgpSecretKeyRing keyRing in keyRings) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.UserIds.Cast <String>().Where(id => id == _userId).Count() > 0) { try { key.ExtractPrivateKey(_passPhrase.ToCharArray()); return(key); } catch { continue; } } } } throw new Exception("Could not find a valid signing key"); }
/// <summary> /// Return the first key we can use to encrypt. /// Note: A file can contain multiple keys (stored in "key rings") /// </summary> private PgpSecretKey getFirstSecretKey(PgpSecretKeyRingBundle secretKeyRingBundle) { foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) { // Note: You may need to use something other than the first key // in your key ring. Keep that in mind. // ex: .Where(k => !k.IsSigningKey) /* * PgpSecretKey key = kRing.GetSecretKeys() * .Cast<PgpSecretKey>() * .Where(k => k.IsSigningKey) * .FirstOrDefault(); * * if (key != null) * { * return key; * } */ IEnumerator ikeys = kRing.GetSecretKeys().GetEnumerator(); if (ikeys.MoveNext()) { PgpSecretKey key = (PgpSecretKey)ikeys.Current; if (key.IsSigningKey) { return(key); } } } return(null); }
private PgpSecretKey GetLastSecretKey(PgpSecretKeyRingBundle secretKeyRingBundle) { return((from PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings() select kRing.GetSecretKeys().Cast <PgpSecretKey>() .LastOrDefault(k => k.IsSigningKey)) .LastOrDefault(key => key != null)); }
private PgpSecretKey ReadSecretKey( Stream inputStream) { PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(inputStream); // // we just loop through the collection till we find a key suitable for encryption, in the real // world you would probably want to be a bit smarter about this. // // // iterate through the key rings. // foreach (PgpSecretKeyRing kRing in pgpSec.GetKeyRings()) { foreach (PgpSecretKey k in kRing.GetSecretKeys()) { if (k.IsSigningKey) { return(k); } } } throw new ArgumentException("Can't find signing key in key ring."); }
private static PgpSecretKey ReadSigningSecretKey(System.IO.Stream keyInStream) { PgpSecretKeyRingBundle pgpSec = CreatePgpSecretKeyRingBundle(keyInStream); PgpSecretKey key = null; System.Collections.IEnumerator rIt = pgpSec.GetKeyRings().GetEnumerator(); while (key == null && rIt.MoveNext()) { PgpSecretKeyRing kRing = (PgpSecretKeyRing)rIt.Current; System.Collections.IEnumerator kIt = kRing.GetSecretKeys().GetEnumerator(); while (key == null && kIt.MoveNext()) { PgpSecretKey k = (PgpSecretKey)kIt.Current; if (k.IsSigningKey) { key = k; } } } if (key == null) { throw new System.Exception("Wrong private key - Can't find signing key in key ring."); } else { return(key); } }
public PgpSecretKey LoadSecretKey(Stream key) { var armoredStream = PgpUtilities.GetDecoderStream(key); var pgpSecretKeyBundle = new PgpSecretKeyRingBundle(armoredStream); foreach (PgpSecretKeyRing keyRing in pgpSecretKeyBundle.GetKeyRings()) { return(keyRing.GetSecretKey()); } throw new ArgumentException("Can't find secret key in key ring."); }
/// <summary> /// Return the first key we can use to encrypt. /// Note: A file can contain multiple keys (stored in "key rings") /// </summary> private PgpSecretKey GetFirstSecretKey(PgpSecretKeyRingBundle secretKeyRingBundle) { foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) { PgpSecretKey key = kRing.GetSecretKeys().Cast <PgpSecretKey>().Where(k => k.IsSigningKey).FirstOrDefault(); if (key != null) { return(key); } } return(null); }
public PgpSecretKey GetSecretKeyForSigning(string email) { using (var inputStream = File.OpenRead(Context.PrivateKeyRingFile)) { using (var decoderStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpSecretKeyRingBundle(decoderStream); var emailSearch = "<" + email.ToLower().Trim() + ">"; foreach (PgpSecretKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpSecretKey k in kRing.GetSecretKeys()) { if (!IsSigningKey(k.PublicKey)) { continue; } if (!k.IsMasterKey) { foreach (PgpSignature sig in k.PublicKey.GetSignaturesOfType(24)) { var pubKey = this.GetPublicKey(sig.KeyId); if (!pubKey.IsMasterKey) { continue; } foreach (string id in pubKey.GetUserIds()) { if (id.ToLower().IndexOf(emailSearch) > -1) { return(k); } } } } foreach (string id in k.PublicKey.GetUserIds()) { if (id.ToLower().IndexOf(emailSearch) > -1) { return(k); } } } } return(null); } } }
private PgpSecretKey readSecretKey(PgpSecretKeyRingBundle bundle) { var keyRings = bundle.GetKeyRings(); foreach (var keyRing in keyRings) { if (keyRing is PgpSecretKeyRing) { return(((PgpSecretKeyRing)keyRing).GetSecretKey()); } } throw new ArgumentException("Secret Key for message not found"); }
public static PgpPrivateKey FindSecretKeyByUserId(PgpSecretKeyRingBundle pgpSec, string userId, char[] pass) { foreach (PgpSecretKeyRing keyRing in pgpSec.GetKeyRings(userId, true, true)) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { return(key.ExtractPrivateKey(pass)); } } } return(null); }
/// <summary> /// Return the first key we can use to encrypt. /// Note: A file can contain multiple keys (stored in "key rings") /// </summary> protected PgpSecretKey GetFirstSecretKey(PgpSecretKeyRingBundle PGP_SecretKeyRingBundle) { foreach (PgpSecretKeyRing PGP_SecretKeyRing in PGP_SecretKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey PGP_SecretKey in PGP_SecretKeyRing.GetSecretKeys()) { if (PGP_SecretKey.IsSigningKey) { return(PGP_SecretKey); } } } return(null); }
public string[] GetSecretKeyUserIds() { using (var inputStream = File.OpenRead(Context.PrivateKeyRingFile)) { using (var decoderStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpSecretKeyRingBundle(decoderStream); var keyUserIds = new List <string>(); foreach (PgpSecretKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpSecretKey k in kRing.GetSecretKeys()) { if (!k.IsMasterKey) { foreach (PgpSignature sig in k.PublicKey.GetSignaturesOfType(24)) { var pubKey = this.GetPublicKey(sig.KeyId); if (!pubKey.IsMasterKey) { continue; } foreach (string id in pubKey.GetUserIds()) { if (!keyUserIds.Contains(id)) { keyUserIds.Add(id); } } } } foreach (string id in k.PublicKey.GetUserIds()) { if (!keyUserIds.Contains(id)) { keyUserIds.Add(id); } } } } return(keyUserIds.ToArray()); } } }
/// <summary> /// Opens a key ring file and loads the first available key suitable for signature generation. /// </summary> /// <param name="inputStream"></param> /// <returns></returns> /// <exception cref="IOException"></exception> /// <exception cref="PgpException"></exception> internal static PgpSecretKey ReadSecretKey(Stream inputStream) { PgpSecretKeyRingBundle _pgpSecKeyRingBundle = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(inputStream)); foreach (PgpSecretKeyRing _pgpSecKeyRing in _pgpSecKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey _pgpSecKey in _pgpSecKeyRing.GetSecretKeys()) { if (_pgpSecKey.IsSigningKey) { return(_pgpSecKey); } } } throw new ArgumentException("Signing key not found in key ring."); }
/// <summary> /// Simple routine that opens a key ring file and loads the first available key /// suitable for signature generation. /// </summary> /// <param name="keyringStream"> /// Input stream to read the secret key ring collection from. /// </param> /// <returns> /// Returns the first available <see cref="PgpSecretKey"/>. /// </returns> public static PgpSecretKey ReadSecretKey(Stream keyringStream) { var secretKeyRingBundle = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(keyringStream)); foreach (PgpSecretKeyRing secretKeyRing in secretKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey secretKey in secretKeyRing.GetSecretKeys()) { if (secretKey.IsSigningKey) { return(secretKey); } } } throw new ArgumentException("Can't find signing key in key ring."); }
public static PgpSecretKey LoadSecretKey(string key) { using (Stream s = Tools.GenerateStreamFromString(key)) { var pgp = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(s)); foreach (PgpSecretKeyRing keyRing in pgp.GetKeyRings()) { foreach (PgpSecretKey secretKey in keyRing.GetSecretKeys()) { if (secretKey.IsSigningKey) { return(secretKey); } } } } return(null); }
/** * A simple routine that opens a key ring file and loads the first available key * suitable for signature generation. * * @param input stream to read the secret key ring collection from. * @return a secret key. * @throws IOException on a problem with using the input stream. * @throws PGPException if there is an issue parsing the input stream. */ internal static PgpSecretKey ReadSecretKey(Stream input) { var pgpSec = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(input)); foreach (PgpSecretKeyRing keyRing in pgpSec.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { return(key); } } } throw new ArgumentException("Can't find signing key in key ring."); }
private static PgpPrivateKey ReadPrivateKey(string keyFile, string passPhrase) { var keyStream = File.OpenRead(keyFile); var decoderStream = PgpUtilities.GetDecoderStream(keyStream); var keyBundle = new PgpSecretKeyRingBundle(decoderStream); foreach (var keyRing in keyBundle.GetKeyRings().Cast <PgpSecretKeyRing>()) { foreach (var key in keyRing.GetSecretKeys().Cast <PgpSecretKey>()) { if (!key.IsPrivateKeyEmpty) { return(key.ExtractPrivateKey(passPhrase.ToCharArray())); } } } return(null); }
public static string GetKeyFingerprint(string keyFile) { var keyStream = File.OpenRead(keyFile); var decoderStream = PgpUtilities.GetDecoderStream(keyStream); var keyBundle = new PgpSecretKeyRingBundle(decoderStream); foreach (var keyRing in keyBundle.GetKeyRings().Cast <PgpSecretKeyRing>()) { foreach (var key in keyRing.GetSecretKeys().Cast <PgpSecretKey>()) { if (key.IsMasterKey) { return(Hex.ToHexString(key.PublicKey.GetFingerprint())); } } } return(null); }
public PgpSecretKey LoadSecKey(string path) { using (Stream keyIn = File.OpenRead(path)) { Stream decStream = PgpUtilities.GetDecoderStream(keyIn); PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(decStream); foreach (PgpSecretKeyRing keyRing in pgpSec.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { return(key); } } } throw new ArgumentException("Can't find signing key in key ring."); } }
/// <summary> /// Reads and returns the PGP secret key from the specified input stream. /// </summary> /// <param name="input">The input stream containing the PGP secret key to be read.</param> /// <returns>The retrieved PGP secret key.</returns> private static PgpSecretKey ReadSecretKey(Stream input) { try { PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(input)); PgpSecretKeyRing pgpKeyRing = pgpSec.GetKeyRings().OfType <PgpSecretKeyRing>().FirstOrDefault(); PgpSecretKey pgpSecretKey = pgpKeyRing.GetSecretKeys().OfType <PgpSecretKey>().FirstOrDefault(); if (pgpSecretKey.IsSigningKey) { return(pgpSecretKey); } else { throw new Exception(); } } catch (Exception) { throw new PgpKeyValidationException("Can't find a valid signing key in the specified key ring."); } }
private static PgpSecretKey ReadSigningKey(string keyFile) { var keyStream = File.OpenRead(keyFile); var decoderStream = PgpUtilities.GetDecoderStream(keyStream); var keyBundle = new PgpSecretKeyRingBundle(decoderStream); PgpSecretKey signingKey = null; foreach (var keyRing in keyBundle.GetKeyRings().Cast <PgpSecretKeyRing>()) { foreach (var key in keyRing.GetSecretKeys().Cast <PgpSecretKey>()) { if (key.IsSigningKey) { signingKey = key; } } } keyStream.Dispose(); return(signingKey); }
private static PgpSecretKey ReadSecretKey(Stream inputStream) { var decodedInputStream = PgpUtilities.GetDecoderStream(inputStream); var secretKeyRingBundle = new PgpSecretKeyRingBundle(decodedInputStream); // we just loop through the collection till we find a key suitable for encryption, in the real // world you would probably want to be a bit smarter about this. foreach (PgpSecretKeyRing keyRing in secretKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { return(key); } } } throw new ArgumentException("Can't find signing key in key ring."); }
/// <summary> /// The read secret key. /// </summary> /// <param name="privateKeyPath"> /// The private key path. /// </param> /// <param name="signing"> /// Is it the signing key we are looking for? /// </param> /// <returns> /// The <see cref="PgpSecretKey"/>. /// </returns> /// <exception cref="ArgumentException"> /// Throws a <see cref="ArgumentException"/> if no key is available. /// </exception> private PgpSecretKey ReadSecretKey(string privateKeyPath, bool signing) { using (Stream keyringStream = File.OpenRead(privateKeyPath)) using (Stream inputStream = PgpUtilities.GetDecoderStream(keyringStream)) { PgpSecretKeyRingBundle secretKeyRingBundle = new PgpSecretKeyRingBundle(inputStream); foreach (PgpSecretKeyRing keyRing in secretKeyRingBundle.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key != null && key.IsSigningKey == signing) { return(key); } } } } throw new ArgumentException("Can't find signing key in key ring."); }
/// <summary> /// Imports a secret pgp keyring bundle. /// </summary> /// <remarks> /// Imports a secret pgp keyring bundle. /// </remarks> /// <param name="bundle">The pgp keyring bundle.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="bundle"/> is <c>null</c>. /// </exception> public virtual void Import(PgpSecretKeyRingBundle bundle) { if (bundle == null) { throw new ArgumentNullException(nameof(bundle)); } int secretKeysAdded = 0; foreach (PgpSecretKeyRing secring in bundle.GetKeyRings()) { SecretKeyRingBundle = PgpSecretKeyRingBundle.AddSecretKeyRing(SecretKeyRingBundle, secring); secretKeysAdded++; } if (secretKeysAdded > 0) { SaveSecretKeyRingBundle(); } }
public static bool ValidatePassPhrase(byte[] privateKey, string passPhrase) { using (MemoryStream privateKeyStream = new MemoryStream(privateKey)) { PgpSecretKeyRingBundle pgpKeyRing = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(privateKeyStream)); var items = pgpKeyRing.GetKeyRings(); foreach (var item in items) { try { var i = (PgpSecretKeyRing)item; var key = i.GetSecretKey().ExtractPrivateKey(passPhrase.ToCharArray()); return(true); } catch (Exception ex) { Insights.Report(ex); return(false); } } } return(true); }
/// <summary> /// Return the first key we can use to encrypt. /// Note: A file can contain multiple keys (stored in "key rings") /// </summary> private PgpSecretKey getFirstSecretKey(PgpSecretKeyRingBundle secretKeyRingBundle) { foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) { // Note: You may need to use something other than the first key // in your key ring. Keep that in mind. // ex: .Where(k => !k.IsSigningKey) PgpSecretKey key = kRing.GetSecretKeys() .Cast <PgpSecretKey>() //.Where(k => k.IsSigningKey) .Where(k => !k.IsSigningKey) .FirstOrDefault(); if (key != null) { return(key); } } return(null); }
static PgpSecretKey GetSecretKey(string path) { using (Stream keyIn = File.OpenRead(path)) { using (Stream inputStream = PgpUtilities.GetDecoderStream(keyIn)) { var secretKeyRingBundle = new PgpSecretKeyRingBundle(inputStream); foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) { PgpSecretKey key = kRing.GetSecretKeys() .Cast <PgpSecretKey>() .Where(k => k.IsSigningKey) .FirstOrDefault(); if (key != null) { return(key); } } } } return(null); }
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 EccKeyTest() { var secretRings = new PgpSecretKeyRingBundle(_eccSec1); var count = 0; foreach (PgpSecretKeyRing secretKeyRing in secretRings.GetKeyRings()) { count++; CheckEccKey(secretKeyRing); } if (count != 1) { Fail("wrong number of secret keyrings"); } }
private PgpSecretKey ReadSecretKey( Stream inputStream) { PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(inputStream); // // we just loop through the collection till we find a key suitable for encryption, in the real // world you would probably want to be a bit smarter about this. // // // iterate through the key rings. // foreach (PgpSecretKeyRing kRing in pgpSec.GetKeyRings()) { foreach (PgpSecretKey k in kRing.GetSecretKeys()) { if (k.IsSigningKey) { return k; } } } throw new ArgumentException("Can't find signing key in key ring."); }
public void RewrapTest() { SecureRandom rand = new SecureRandom(); // Read the secret key rings PgpSecretKeyRingBundle privRings = new PgpSecretKeyRingBundle( new MemoryStream(rewrapKey, false)); foreach (PgpSecretKeyRing pgpPrivEnum in privRings.GetKeyRings()) { foreach (PgpSecretKey pgpKeyEnum in pgpPrivEnum.GetSecretKeys()) { // re-encrypt the key with an empty password PgpSecretKeyRing pgpPriv = PgpSecretKeyRing.RemoveSecretKey(pgpPrivEnum, pgpKeyEnum); PgpSecretKey pgpKey = PgpSecretKey.CopyWithNewPassword( pgpKeyEnum, rewrapPass, null, SymmetricKeyAlgorithmTag.Null, rand); pgpPriv = PgpSecretKeyRing.InsertSecretKey(pgpPriv, pgpKey); // this should succeed PgpPrivateKey privTmp = pgpKey.ExtractPrivateKey(null); } } }
private void checkSecretKeyRingWithPersonalCertificate( byte[] keyRing) { PgpSecretKeyRingBundle secCol = new PgpSecretKeyRingBundle(keyRing); int count = 0; foreach (PgpSecretKeyRing ring in secCol.GetKeyRings()) { IEnumerator e = ring.GetExtraPublicKeys().GetEnumerator(); while (e.MoveNext()) { ++count; } } if (count != 1) { Fail("personal certificate data subkey not found - count = " + count); } }
public void PerformTest9() { PgpSecretKeyRingBundle secretRings1 = new PgpSecretKeyRingBundle(sec9); int count = 0; byte[] 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++; PgpPrivateKey pKey = k.ExtractPrivateKey(sec9pass); if (keyCount == 1 && pKey != null) { Fail("primary secret key found, null expected"); } } if (keyCount != 3) { Fail("wrong number of secret keys"); } } if (count != 1) { Fail("wrong number of secret keyrings"); } }
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 PerformTest4() { PgpSecretKeyRingBundle secretRings1 = new PgpSecretKeyRingBundle(sec4); int count = 0; byte[] 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(sec3pass1); } if (keyCount != 2) { Fail("wrong number of secret keys"); } } if (count != 1) { 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"); } }
/** * A simple routine that opens a key ring file and loads the first available key * suitable for signature generation. * * @param input stream to read the secret key ring collection from. * @return a secret key. * @throws IOException on a problem with using the input stream. * @throws PGPException if there is an issue parsing the input stream. */ internal static PgpSecretKey ReadSecretKey(Stream input) { PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle( PgpUtilities.GetDecoderStream(input)); // // we just loop through the collection till we find a key suitable for encryption, in the real // world you would probably want to be a bit smarter about this. // foreach (PgpSecretKeyRing keyRing in pgpSec.GetKeyRings()) { foreach (PgpSecretKey key in keyRing.GetSecretKeys()) { if (key.IsSigningKey) { return key; } } } throw new ArgumentException("Can't find signing key in key ring."); }
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 RewrapTestV3() { // Read the secret key rings PgpSecretKeyRingBundle privRings = new PgpSecretKeyRingBundle( new MemoryStream(privv3, false)); char[] newPass = "******".ToCharArray(); foreach (PgpSecretKeyRing pgpPrivEnum in privRings.GetKeyRings()) { PgpSecretKeyRing pgpPriv = pgpPrivEnum; foreach (PgpSecretKey pgpKeyEnum in pgpPriv.GetSecretKeys()) { long oldKeyID = pgpKeyEnum.KeyId; // re-encrypt the key with an empty password pgpPriv = PgpSecretKeyRing.RemoveSecretKey(pgpPriv, pgpKeyEnum); PgpSecretKey pgpKey = PgpSecretKey.CopyWithNewPassword( pgpKeyEnum, v3KeyPass, null, SymmetricKeyAlgorithmTag.Null, Random); pgpPriv = PgpSecretKeyRing.InsertSecretKey(pgpPriv, pgpKey); // this should succeed PgpPrivateKey privTmp = pgpKey.ExtractPrivateKey(null); if (pgpKey.KeyId != oldKeyID) { Fail("key ID mismatch"); } } foreach (PgpSecretKey pgpKeyEnum in pgpPriv.GetSecretKeys()) { long oldKeyID = pgpKeyEnum.KeyId; // re-encrypt the key with an empty password pgpPriv = PgpSecretKeyRing.RemoveSecretKey(pgpPriv, pgpKeyEnum); PgpSecretKey pgpKey = PgpSecretKey.CopyWithNewPassword( pgpKeyEnum, null, newPass, SymmetricKeyAlgorithmTag.Cast5, Random); pgpPriv = PgpSecretKeyRing.InsertSecretKey(pgpPriv, pgpKey); // this should succeed PgpPrivateKey privTmp = pgpKey.ExtractPrivateKey(newPass); if (pgpKey.KeyId != oldKeyID) { Fail("key ID mismatch"); } } } }