/// <summary>Construct a version 4 public subkey packet.</summary> public PublicSubkeyPacket( PublicKeyAlgorithmTag algorithm, DateTime time, IBcpgKey key) : base(algorithm, time, key) { }
internal PublicKeyPacket( BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); time = ((uint)bcpgIn.ReadByte() << 24) | ((uint)bcpgIn.ReadByte() << 16) | ((uint)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte(); if (version <= 3) { validDays = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); } algorithm = (PublicKeyAlgorithmTag) bcpgIn.ReadByte(); switch ((PublicKeyAlgorithmTag) algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: key = new RsaPublicBcpgKey(bcpgIn); break; case PublicKeyAlgorithmTag.Dsa: key = new DsaPublicBcpgKey(bcpgIn); break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: key = new ElGamalPublicBcpgKey(bcpgIn); break; default: throw new IOException("unknown PGP public key algorithm encountered"); } }
private static IBufferedCipher GetKeyCipher( PublicKeyAlgorithmTag algorithm) { try { switch (algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: return CipherUtilities.GetCipher("RSA//PKCS1Padding"); case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: return CipherUtilities.GetCipher("ElGamal/ECB/PKCS1Padding"); default: throw new PgpException("unknown asymmetric algorithm: " + algorithm); } } catch (PgpException e) { throw e; } catch (Exception e) { throw new PgpException("Exception creating cipher", e); } }
public SignaturePacket( int version, int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, ISignatureSubpacket[] hashedData, ISignatureSubpacket[] unhashedData, byte[] fingerprint, MPInteger[] signature) { this._version = version; this._signatureType = signatureType; this._keyId = keyId; this._keyAlgorithm = keyAlgorithm; this._hashAlgorithm = hashAlgorithm; this._hashedData = hashedData; this._unhashedData = unhashedData; this._fingerprint = fingerprint; this._signature = signature; if (hashedData != null) { SetCreationTime(); } }
public PgpKeyPair( PublicKeyAlgorithmTag algorithm, AsymmetricCipherKeyPair keyPair, DateTime time) : this(algorithm, keyPair.Public, keyPair.Private, time) { }
public static string GetSignatureName( PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { string encAlg; switch (keyAlgorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: encAlg = "RSA"; break; case PublicKeyAlgorithmTag.Dsa: encAlg = "DSA"; break; case PublicKeyAlgorithmTag.ECDH: encAlg = "ECDH"; break; case PublicKeyAlgorithmTag.ECDsa: encAlg = "ECDSA"; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: // in some malformed cases. case PublicKeyAlgorithmTag.ElGamalGeneral: encAlg = "ElGamal"; break; default: throw new PgpException("unknown algorithm tag in signature:" + keyAlgorithm); } return GetDigestName(hashAlgorithm) + "with" + encAlg; }
internal PublicKeyEncSessionPacket( BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); keyId |= (long)bcpgIn.ReadByte() << 56; keyId |= (long)bcpgIn.ReadByte() << 48; keyId |= (long)bcpgIn.ReadByte() << 40; keyId |= (long)bcpgIn.ReadByte() << 32; keyId |= (long)bcpgIn.ReadByte() << 24; keyId |= (long)bcpgIn.ReadByte() << 16; keyId |= (long)bcpgIn.ReadByte() << 8; keyId |= (uint)bcpgIn.ReadByte(); algorithm = (PublicKeyAlgorithmTag) bcpgIn.ReadByte(); switch ((PublicKeyAlgorithmTag) algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: data = new BigInteger[]{ new MPInteger(bcpgIn).Value }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: data = new BigInteger[] { new MPInteger(bcpgIn).Value, new MPInteger(bcpgIn).Value }; break; default: throw new IOException("unknown PGP public key algorithm encountered"); } }
/// <summary> /// Construct a version 4 public key packet. /// </summary> /// <param name="algorithm">The algorithm.</param> /// <param name="time">The time.</param> /// <param name="key">The key.</param> public PublicKeyPacket(PublicKeyAlgorithmTag algorithm, DateTime time, IBcpgPublicKey key) { _version = 4; _time = DateTimeUtilities.DateTimeToUnixMs(time) / 1000L; _algorithm = algorithm; _key = key; }
public static string GetAlgorithm( PublicKeyAlgorithmTag algId) { switch (algId) { case PublicKeyAlgorithmTag.RsaGeneral: return "RsaGeneral"; case PublicKeyAlgorithmTag.RsaEncrypt: return "RsaEncrypt"; case PublicKeyAlgorithmTag.RsaSign: return "RsaSign"; case PublicKeyAlgorithmTag.ElGamalEncrypt: return "ElGamalEncrypt"; case PublicKeyAlgorithmTag.Dsa: return "DSA"; case PublicKeyAlgorithmTag.EC: return "EC"; case PublicKeyAlgorithmTag.ECDsa: return "ECDSA"; case PublicKeyAlgorithmTag.ElGamalGeneral: return "ElGamalGeneral"; case PublicKeyAlgorithmTag.DiffieHellman: return "DiffieHellman"; } return "unknown"; }
/// <summary>Create a generator for the passed in keyAlgorithm and hashAlgorithm codes.</summary> public PgpSignatureGenerator(PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { _keyAlgorithm = keyAlgorithm; _hashAlgorithm = hashAlgorithm; _dig = DigestUtilities.GetDigest(PgpUtilities.GetDigestName(hashAlgorithm)); _sig = SignerUtilities.GetSigner(PgpUtilities.GetSignatureName(keyAlgorithm, hashAlgorithm)); }
public PublicKeyEncSessionPacket(long keyId, PublicKeyAlgorithmTag algorithm, BigInteger[] data, byte[] extraData) { _version = 3; _keyId = keyId; _algorithm = algorithm; _data = (IBigInteger[])data.Clone(); _extraData = extraData != null ? (byte[])extraData.Clone() : null; }
public RevocationKey( bool isCritical, RevocationKeyTag signatureClass, PublicKeyAlgorithmTag keyAlgorithm, byte[] fingerprint) : base(SignatureSubpacketTag.RevocationKey, isCritical, false, CreateData(signatureClass, keyAlgorithm, fingerprint)) { }
public PgpKeyPair( PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, AsymmetricKeyParameter privKey, DateTime time) { this.pub = new PgpPublicKey(algorithm, pubKey, time); this.priv = new PgpPrivateKey(privKey, pub.KeyId); }
/// <summary> /// Create a PgpPublicKey from the passed in lightweight one. /// </summary> /// <remarks> /// Note: the time passed in affects the value of the key's keyId, so you probably only want /// to do this once for a lightweight key, or make sure you keep track of the time you used. /// </remarks> /// <param name="algorithm">Asymmetric algorithm type representing the public key.</param> /// <param name="pubKey">Actual public key to associate.</param> /// <param name="time">Date of creation.</param> /// <exception cref="ArgumentException">If <c>pubKey</c> is not public.</exception> /// <exception cref="PgpException">On key creation problem.</exception> public PgpPublicKey(PublicKeyAlgorithmTag algorithm, IAsymmetricKeyParameter pubKey, DateTime time) { if (pubKey.IsPrivate) throw new ArgumentException(@"Expected a public key", "pubKey"); IBcpgPublicKey bcpgKey; if (pubKey is RsaKeyParameters) { var rK = (RsaKeyParameters)pubKey; bcpgKey = new RsaPublicBcpgKey(rK.Modulus, rK.Exponent); } else if (pubKey is DsaPublicKeyParameters) { var dK = (DsaPublicKeyParameters)pubKey; var dP = dK.Parameters; bcpgKey = new DsaPublicBcpgKey(dP.P, dP.Q, dP.G, dK.Y); } else if (pubKey is ElGamalPublicKeyParameters) { var eK = (ElGamalPublicKeyParameters)pubKey; var eS = eK.Parameters; bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y); } else if (pubKey is ECDHPublicKeyParameters) { var ecdh = (ECDHPublicKeyParameters)pubKey; bcpgKey = new ECDHPublicBcpgKey(ecdh.Q, ecdh.PublicKeyParamSet, ecdh.HashAlgorithm, ecdh.SymmetricKeyAlgorithm); } else if (pubKey is ECPublicKeyParameters) { var ecdsa = (ECPublicKeyParameters)pubKey; bcpgKey = new ECDSAPublicBcpgKey(ecdsa.Q, ecdsa.PublicKeyParamSet); } else { throw new PgpException("unknown key class"); } _publicPk = new PublicKeyPacket(algorithm, time, bcpgKey); _ids = Platform.CreateArrayList(); _idSigs = Platform.CreateArrayList<IList<IPgpSignature>>(); try { Init(); } catch (IOException e) { throw new PgpException("exception calculating keyId", e); } }
/// <summary>Construct a version 4 public key packet.</summary> public PublicKeyPacket( PublicKeyAlgorithmTag algorithm, DateTime time, IBcpgKey key) { this.version = 4; this.time = DateTimeUtilities.DateTimeToUnixMs(time) / 1000L; this.algorithm = algorithm; this.key = key; }
public PublicKeyEncSessionPacket( long keyId, PublicKeyAlgorithmTag algorithm, BigInteger[] data) { this.version = 3; this.keyId = keyId; this.algorithm = algorithm; this.data = (BigInteger[]) data.Clone(); }
/// <summary>Create a generator for the passed in keyAlgorithm and hashAlgorithm codes.</summary> public PgpV3SignatureGenerator( PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { this.keyAlgorithm = keyAlgorithm; this.hashAlgorithm = hashAlgorithm; dig = DigestUtilities.GetDigest(PgpUtilities.GetDigestName(hashAlgorithm)); sig = SignerUtilities.GetSigner(PgpUtilities.GetSignatureName(keyAlgorithm, hashAlgorithm)); }
private static byte[] CreateData( RevocationKeyTag signatureClass, PublicKeyAlgorithmTag keyAlgorithm, byte[] fingerprint) { byte[] data = new byte[2 + fingerprint.Length]; data[0] = (byte)signatureClass; data[1] = (byte)keyAlgorithm; Array.Copy(fingerprint, 0, data, 2, fingerprint.Length); return data; }
/** * Generate a version 4 signature packet. * * @param signatureType * @param keyAlgorithm * @param hashAlgorithm * @param hashedData * @param unhashedData * @param fingerprint * @param signature */ public SignaturePacket( int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, SignatureSubpacket[] hashedData, SignatureSubpacket[] unhashedData, byte[] fingerprint, MPInteger[] signature) : this(4, signatureType, keyId, keyAlgorithm, hashAlgorithm, hashedData, unhashedData, fingerprint, signature) { }
/** * Generate a version 2/3 signature packet. * * @param signatureType * @param keyAlgorithm * @param hashAlgorithm * @param fingerprint * @param signature */ public SignaturePacket( int version, int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, long creationTime, byte[] fingerprint, MPInteger[] signature) : this(version, signatureType, keyId, keyAlgorithm, hashAlgorithm, null, null, fingerprint, signature) { this.creationTime = creationTime; }
public OnePassSignaturePacket( int sigType, HashAlgorithmTag hashAlgorithm, PublicKeyAlgorithmTag keyAlgorithm, long keyId, bool isNested) { this.version = 3; this.sigType = sigType; this.hashAlgorithm = hashAlgorithm; this.keyAlgorithm = keyAlgorithm; this.keyId = keyId; this.nested = (isNested) ? 0 : 1; }
public PublicKeyEncSessionPacket( long keyId, PublicKeyAlgorithmTag algorithm, byte[][] data) { this.version = 3; this.keyId = keyId; this.algorithm = algorithm; this.data = new byte[data.Length][]; for (int i = 0; i < data.Length; ++i) { this.data[i] = Arrays.Clone(data[i]); } }
public PgpSecretKey( int certificationLevel, PublicKeyAlgorithmTag algorithm, IAsymmetricKeyParameter pubKey, IAsymmetricKeyParameter privKey, DateTime time, string id, SymmetricKeyAlgorithmTag encAlgorithm, char[] passPhrase, bool useSha1, PgpSignatureSubpacketVector hashedPackets, PgpSignatureSubpacketVector unhashedPackets, SecureRandom rand) : this(certificationLevel, new PgpKeyPair(algorithm, pubKey, privKey, time), id, encAlgorithm, passPhrase, useSha1, hashedPackets, unhashedPackets, rand) { }
/// <summary> /// Create a PgpPublicKey from the passed in JCA one. /// <p> /// Note: the time passed in affects the value of the key's keyId, so you probably only want /// to do this once for a JCA key, or make sure you keep track of the time you used.</p> /// </summary> public PgpPublicKey( PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, DateTime time) { if (pubKey.IsPrivate) throw new ArgumentException("Expected a public key", "pubKey"); IBcpgKey bcpgKey; if (pubKey is RsaKeyParameters) { RsaKeyParameters rK = (RsaKeyParameters) pubKey; bcpgKey = new RsaPublicBcpgKey(rK.Modulus, rK.Exponent); } else if (pubKey is DsaPublicKeyParameters) { DsaPublicKeyParameters dK = (DsaPublicKeyParameters) pubKey; DsaParameters dP = dK.Parameters; bcpgKey = new DsaPublicBcpgKey(dP.P, dP.Q, dP.G, dK.Y); } else if (pubKey is ElGamalPublicKeyParameters) { ElGamalPublicKeyParameters eK = (ElGamalPublicKeyParameters) pubKey; ElGamalParameters eS = eK.Parameters; bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y); } else { throw new PgpException("unknown key class"); } this.publicPk = new PublicKeyPacket(algorithm, time, bcpgKey); this.ids = new ArrayList(); this.idSigs = new ArrayList(); try { Init(); } catch (IOException e) { throw new PgpException("exception calculating keyId", e); } }
internal OnePassSignaturePacket( BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); sigType = bcpgIn.ReadByte(); hashAlgorithm = (HashAlgorithmTag) bcpgIn.ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag) bcpgIn.ReadByte(); keyId |= (long)bcpgIn.ReadByte() << 56; keyId |= (long)bcpgIn.ReadByte() << 48; keyId |= (long)bcpgIn.ReadByte() << 40; keyId |= (long)bcpgIn.ReadByte() << 32; keyId |= (long)bcpgIn.ReadByte() << 24; keyId |= (long)bcpgIn.ReadByte() << 16; keyId |= (long)bcpgIn.ReadByte() << 8; keyId |= (uint)bcpgIn.ReadByte(); nested = bcpgIn.ReadByte(); }
internal PublicKeyEncSessionPacket(BcpgInputStream bcpgIn) { _version = bcpgIn.ReadByte(); _keyId |= (long)bcpgIn.ReadByte() << 56; _keyId |= (long)bcpgIn.ReadByte() << 48; _keyId |= (long)bcpgIn.ReadByte() << 40; _keyId |= (long)bcpgIn.ReadByte() << 32; _keyId |= (long)bcpgIn.ReadByte() << 24; _keyId |= (long)bcpgIn.ReadByte() << 16; _keyId |= (long)bcpgIn.ReadByte() << 8; _keyId |= (uint)bcpgIn.ReadByte(); _algorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); switch (_algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: _data = new[] { new MPInteger(bcpgIn).Value }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: _data = new[] { new MPInteger(bcpgIn).Value, new MPInteger(bcpgIn).Value }; break; case PublicKeyAlgorithmTag.Ecdh: _data = new[] { new MPInteger(bcpgIn).Value }; var length = bcpgIn.ReadByte(); if (length > 0xFF) throw new IOException("EC DH symmetric key data is too long."); _extraData = new byte[length]; bcpgIn.ReadFully(_extraData, 0, length); break; default: throw new IOException("unknown PGP public key algorithm encountered"); } }
public SignaturePacket( int version, int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, SignatureSubpacket[] hashedData, SignatureSubpacket[] unhashedData, byte[] fingerprint, MPInteger[] signature) { this.version = version; this.signatureType = signatureType; this.keyId = keyId; this.keyAlgorithm = keyAlgorithm; this.hashAlgorithm = hashAlgorithm; this.hashedData = hashedData; this.unhashedData = unhashedData; this.fingerprint = fingerprint; this.signature = signature; }
internal PublicKeyEncSessionPacket( BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); keyId |= (long)bcpgIn.ReadByte() << 56; keyId |= (long)bcpgIn.ReadByte() << 48; keyId |= (long)bcpgIn.ReadByte() << 40; keyId |= (long)bcpgIn.ReadByte() << 32; keyId |= (long)bcpgIn.ReadByte() << 24; keyId |= (long)bcpgIn.ReadByte() << 16; keyId |= (long)bcpgIn.ReadByte() << 8; keyId |= (uint)bcpgIn.ReadByte(); algorithm = (PublicKeyAlgorithmTag) bcpgIn.ReadByte(); switch ((PublicKeyAlgorithmTag) algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: data = new byte[][]{ new MPInteger(bcpgIn).GetEncoded() }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: MPInteger p = new MPInteger(bcpgIn); MPInteger g = new MPInteger(bcpgIn); data = new byte[][]{ p.GetEncoded(), g.GetEncoded(), }; break; case PublicKeyAlgorithmTag.ECDH: data = new byte[][]{ Streams.ReadAll(bcpgIn) }; break; default: throw new IOException("unknown PGP public key algorithm encountered"); } }
internal SignaturePacket(BcpgInputStream bcpgIn) { this.version = bcpgIn.ReadByte(); if (this.version == 3 || this.version == 2) { bcpgIn.ReadByte(); this.signatureType = bcpgIn.ReadByte(); this.creationTime = ((long)bcpgIn.ReadByte() << 24 | (long)bcpgIn.ReadByte() << 16 | (long)bcpgIn.ReadByte() << 8 | (long)((ulong)bcpgIn.ReadByte())) * 1000L; this.keyId |= (long)bcpgIn.ReadByte() << 56; this.keyId |= (long)bcpgIn.ReadByte() << 48; this.keyId |= (long)bcpgIn.ReadByte() << 40; this.keyId |= (long)bcpgIn.ReadByte() << 32; this.keyId |= (long)bcpgIn.ReadByte() << 24; this.keyId |= (long)bcpgIn.ReadByte() << 16; this.keyId |= (long)bcpgIn.ReadByte() << 8; this.keyId |= (long)((ulong)bcpgIn.ReadByte()); this.keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); this.hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); } else { if (this.version != 4) { throw new Exception("unsupported version: " + this.version); } this.signatureType = bcpgIn.ReadByte(); this.keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); this.hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); int num = bcpgIn.ReadByte() << 8 | bcpgIn.ReadByte(); byte[] buffer = new byte[num]; bcpgIn.ReadFully(buffer); SignatureSubpacketsParser signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer, false)); IList list = Platform.CreateArrayList(); SignatureSubpacket value; while ((value = signatureSubpacketsParser.ReadPacket()) != null) { list.Add(value); } this.hashedData = new SignatureSubpacket[list.Count]; for (int num2 = 0; num2 != this.hashedData.Length; num2++) { SignatureSubpacket signatureSubpacket = (SignatureSubpacket)list[num2]; if (signatureSubpacket is IssuerKeyId) { this.keyId = ((IssuerKeyId)signatureSubpacket).KeyId; } else if (signatureSubpacket is SignatureCreationTime) { this.creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket).GetTime()); } this.hashedData[num2] = signatureSubpacket; } int num3 = bcpgIn.ReadByte() << 8 | bcpgIn.ReadByte(); byte[] buffer2 = new byte[num3]; bcpgIn.ReadFully(buffer2); signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer2, false)); list.Clear(); while ((value = signatureSubpacketsParser.ReadPacket()) != null) { list.Add(value); } this.unhashedData = new SignatureSubpacket[list.Count]; for (int num4 = 0; num4 != this.unhashedData.Length; num4++) { SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list[num4]; if (signatureSubpacket2 is IssuerKeyId) { this.keyId = ((IssuerKeyId)signatureSubpacket2).KeyId; } this.unhashedData[num4] = signatureSubpacket2; } } this.fingerprint = new byte[2]; bcpgIn.ReadFully(this.fingerprint); PublicKeyAlgorithmTag publicKeyAlgorithmTag = this.keyAlgorithm; switch (publicKeyAlgorithmTag) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: { MPInteger mPInteger = new MPInteger(bcpgIn); this.signature = new MPInteger[] { mPInteger }; return; } case PublicKeyAlgorithmTag.RsaEncrypt: break; default: switch (publicKeyAlgorithmTag) { case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: { MPInteger mPInteger2 = new MPInteger(bcpgIn); MPInteger mPInteger3 = new MPInteger(bcpgIn); MPInteger mPInteger4 = new MPInteger(bcpgIn); this.signature = new MPInteger[] { mPInteger2, mPInteger3, mPInteger4 }; return; } case PublicKeyAlgorithmTag.Dsa: { MPInteger mPInteger5 = new MPInteger(bcpgIn); MPInteger mPInteger6 = new MPInteger(bcpgIn); this.signature = new MPInteger[] { mPInteger5, mPInteger6 }; return; } } break; } if (this.keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && this.keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) { this.signature = null; MemoryStream memoryStream = new MemoryStream(); int num5; while ((num5 = bcpgIn.ReadByte()) >= 0) { memoryStream.WriteByte((byte)num5); } this.signatureEncoding = memoryStream.ToArray(); return; } throw new IOException("unknown signature key algorithm: " + this.keyAlgorithm); }
/// <summary> /// Generate public/secret key ring file. /// </summary> /// <param name="identity"> /// The identity. /// </param> /// <param name="password"> /// The password. /// </param> /// <param name="publicKeyFile"> /// The public key file path. /// </param> /// <param name="privateKeyFile"> /// The private key file path. /// </param> /// <param name="expires"> /// When, if ever, should the key expire; null means never. /// </param> /// <param name="armor"> /// Should output as ASCII armor? /// </param> /// <param name="signKeyLength"> /// Signing keypair length. /// </param> /// <param name="signGenerator"> /// Signing key generator type. /// </param> /// <param name="signingAlgorithm"> /// The signing algorithm. /// </param> /// <param name="encryptKeyLength"> /// Encryption keypair length. /// </param> /// <param name="encryptGenerator"> /// Encryption key generator type. /// </param> /// <param name="encryptionAlgorithm"> /// The encryption algorithm. /// </param> /// <param name="symmetricAlgorithm"> /// The symmetric encryption algorithm. /// </param> public static void GenerateKeyRing( string identity, string password, string publicKeyFile, string privateKeyFile, DateTime?expires, bool armor = false, int signKeyLength = 2048, string signGenerator = "RSA", PublicKeyAlgorithmTag signingAlgorithm = PublicKeyAlgorithmTag.RsaSign, int encryptKeyLength = 2048, string encryptGenerator = "RSA", PublicKeyAlgorithmTag encryptionAlgorithm = PublicKeyAlgorithmTag.RsaEncrypt, SymmetricKeyAlgorithmTag symmetricAlgorithm = SymmetricKeyAlgorithmTag.Aes256) { var krgen = CreateKeyRingGenerator( identity, password, expires, signKeyLength, signGenerator, signingAlgorithm, encryptKeyLength, encryptGenerator, encryptionAlgorithm, symmetricAlgorithm); // Generate public key ring, dump to file. var pkr = krgen.GeneratePublicKeyRing(); using (var pubout = (Stream) new FileStream(publicKeyFile, FileMode.Create)) { Stream wrapped = pubout; if (armor) { wrapped = new ArmoredOutputStream(pubout); } pkr.Encode(wrapped); wrapped.Flush(); if (armor) { wrapped.Dispose(); } } // Generate private key, dump to file. var skr = krgen.GenerateSecretKeyRing(); using (var secout = (Stream) new FileStream(privateKeyFile, FileMode.Create)) { Stream wrapped = secout; if (armor) { wrapped = new ArmoredOutputStream(secout); } skr.Encode(wrapped); wrapped.Flush(); if (armor) { wrapped.Dispose(); } } }
public RevocationKey(bool isCritical, RevocationKeyTag signatureClass, PublicKeyAlgorithmTag keyAlgorithm, byte[] fingerprint) : base(SignatureSubpacketTag.RevocationKey, isCritical, isLongLength: false, CreateData(signatureClass, keyAlgorithm, fingerprint)) { }
public PgpSignatureFactoryBuilder(PublicKeyAlgorithmTag keyAlg, HashAlgorithmTag hashAlg) { this.keyAlg = keyAlg; this.hashAlg = hashAlg; }
internal SignaturePacket(BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); if (version == 3 || version == 2) { bcpgIn.ReadByte(); signatureType = bcpgIn.ReadByte(); creationTime = (((long)bcpgIn.ReadByte() << 24) | ((long)bcpgIn.ReadByte() << 16) | ((long)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte()) * 1000; keyId |= (long)bcpgIn.ReadByte() << 56; keyId |= (long)bcpgIn.ReadByte() << 48; keyId |= (long)bcpgIn.ReadByte() << 40; keyId |= (long)bcpgIn.ReadByte() << 32; keyId |= (long)bcpgIn.ReadByte() << 24; keyId |= (long)bcpgIn.ReadByte() << 16; keyId |= (long)bcpgIn.ReadByte() << 8; keyId |= (uint)bcpgIn.ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); } else { if (version != 4) { throw new Exception("unsupported version: " + version); } signatureType = bcpgIn.ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); int num = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); byte[] buffer = new byte[num]; bcpgIn.ReadFully(buffer); SignatureSubpacketsParser signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer, writable: false)); IList list = Platform.CreateArrayList(); SignatureSubpacket value; while ((value = signatureSubpacketsParser.ReadPacket()) != null) { list.Add(value); } hashedData = new SignatureSubpacket[list.Count]; for (int i = 0; i != hashedData.Length; i++) { SignatureSubpacket signatureSubpacket = (SignatureSubpacket)list[i]; if (signatureSubpacket is IssuerKeyId) { keyId = ((IssuerKeyId)signatureSubpacket).KeyId; } else if (signatureSubpacket is SignatureCreationTime) { creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket).GetTime()); } hashedData[i] = signatureSubpacket; } int num2 = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); byte[] buffer2 = new byte[num2]; bcpgIn.ReadFully(buffer2); signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer2, writable: false)); list.Clear(); while ((value = signatureSubpacketsParser.ReadPacket()) != null) { list.Add(value); } unhashedData = new SignatureSubpacket[list.Count]; for (int j = 0; j != unhashedData.Length; j++) { SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list[j]; if (signatureSubpacket2 is IssuerKeyId) { keyId = ((IssuerKeyId)signatureSubpacket2).KeyId; } unhashedData[j] = signatureSubpacket2; } } fingerprint = new byte[2]; bcpgIn.ReadFully(fingerprint); switch (keyAlgorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: { MPInteger mPInteger8 = new MPInteger(bcpgIn); signature = new MPInteger[1] { mPInteger8 }; return; } case PublicKeyAlgorithmTag.Dsa: { MPInteger mPInteger6 = new MPInteger(bcpgIn); MPInteger mPInteger7 = new MPInteger(bcpgIn); signature = new MPInteger[2] { mPInteger6, mPInteger7 }; return; } case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: { MPInteger mPInteger3 = new MPInteger(bcpgIn); MPInteger mPInteger4 = new MPInteger(bcpgIn); MPInteger mPInteger5 = new MPInteger(bcpgIn); signature = new MPInteger[3] { mPInteger3, mPInteger4, mPInteger5 }; return; } case PublicKeyAlgorithmTag.ECDsa: { MPInteger mPInteger = new MPInteger(bcpgIn); MPInteger mPInteger2 = new MPInteger(bcpgIn); signature = new MPInteger[2] { mPInteger, mPInteger2 }; return; } } if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) { signature = null; MemoryStream memoryStream = new MemoryStream(); int num3; while ((num3 = bcpgIn.ReadByte()) >= 0) { memoryStream.WriteByte((byte)num3); } signatureEncoding = memoryStream.ToArray(); return; } throw new IOException("unknown signature key algorithm: " + keyAlgorithm); }
internal SignaturePacket(BcpgInputStream bcpgIn) { //IL_018f: Unknown result type (might be due to invalid IL or missing references) //IL_0199: Expected O, but got Unknown //IL_025a: Unknown result type (might be due to invalid IL or missing references) //IL_0264: Expected O, but got Unknown //IL_0422: Unknown result type (might be due to invalid IL or missing references) //IL_0429: Expected O, but got Unknown //IL_0464: Unknown result type (might be due to invalid IL or missing references) version = ((Stream)bcpgIn).ReadByte(); if (version == 3 || version == 2) { ((Stream)bcpgIn).ReadByte(); signatureType = ((Stream)bcpgIn).ReadByte(); creationTime = (((long)((Stream)bcpgIn).ReadByte() << 24) | ((long)((Stream)bcpgIn).ReadByte() << 16) | ((long)((Stream)bcpgIn).ReadByte() << 8) | (uint)((Stream)bcpgIn).ReadByte()) * 1000; keyId |= (long)((Stream)bcpgIn).ReadByte() << 56; keyId |= (long)((Stream)bcpgIn).ReadByte() << 48; keyId |= (long)((Stream)bcpgIn).ReadByte() << 40; keyId |= (long)((Stream)bcpgIn).ReadByte() << 32; keyId |= (long)((Stream)bcpgIn).ReadByte() << 24; keyId |= (long)((Stream)bcpgIn).ReadByte() << 16; keyId |= (long)((Stream)bcpgIn).ReadByte() << 8; keyId |= (uint)((Stream)bcpgIn).ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)((Stream)bcpgIn).ReadByte(); hashAlgorithm = (HashAlgorithmTag)((Stream)bcpgIn).ReadByte(); } else { if (version != 4) { throw new global::System.Exception(string.Concat((object)"unsupported version: ", (object)version)); } signatureType = ((Stream)bcpgIn).ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)((Stream)bcpgIn).ReadByte(); hashAlgorithm = (HashAlgorithmTag)((Stream)bcpgIn).ReadByte(); int num = (((Stream)bcpgIn).ReadByte() << 8) | ((Stream)bcpgIn).ReadByte(); byte[] array = new byte[num]; bcpgIn.ReadFully(array); SignatureSubpacketsParser signatureSubpacketsParser = new SignatureSubpacketsParser((Stream) new MemoryStream(array, false)); global::System.Collections.IList list = Platform.CreateArrayList(); SignatureSubpacket signatureSubpacket; while ((signatureSubpacket = signatureSubpacketsParser.ReadPacket()) != null) { list.Add((object)signatureSubpacket); } hashedData = new SignatureSubpacket[((global::System.Collections.ICollection)list).get_Count()]; for (int i = 0; i != hashedData.Length; i++) { SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list.get_Item(i); if (signatureSubpacket2 is IssuerKeyId) { keyId = ((IssuerKeyId)signatureSubpacket2).KeyId; } else if (signatureSubpacket2 is SignatureCreationTime) { creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket2).GetTime()); } hashedData[i] = signatureSubpacket2; } int num2 = (((Stream)bcpgIn).ReadByte() << 8) | ((Stream)bcpgIn).ReadByte(); byte[] array2 = new byte[num2]; bcpgIn.ReadFully(array2); signatureSubpacketsParser = new SignatureSubpacketsParser((Stream) new MemoryStream(array2, false)); list.Clear(); while ((signatureSubpacket = signatureSubpacketsParser.ReadPacket()) != null) { list.Add((object)signatureSubpacket); } unhashedData = new SignatureSubpacket[((global::System.Collections.ICollection)list).get_Count()]; for (int j = 0; j != unhashedData.Length; j++) { SignatureSubpacket signatureSubpacket3 = (SignatureSubpacket)list.get_Item(j); if (signatureSubpacket3 is IssuerKeyId) { keyId = ((IssuerKeyId)signatureSubpacket3).KeyId; } unhashedData[j] = signatureSubpacket3; } } fingerprint = new byte[2]; bcpgIn.ReadFully(fingerprint); switch (keyAlgorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: { MPInteger mPInteger8 = new MPInteger(bcpgIn); signature = new MPInteger[1] { mPInteger8 }; return; } case PublicKeyAlgorithmTag.Dsa: { MPInteger mPInteger6 = new MPInteger(bcpgIn); MPInteger mPInteger7 = new MPInteger(bcpgIn); signature = new MPInteger[2] { mPInteger6, mPInteger7 }; return; } case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: { MPInteger mPInteger3 = new MPInteger(bcpgIn); MPInteger mPInteger4 = new MPInteger(bcpgIn); MPInteger mPInteger5 = new MPInteger(bcpgIn); signature = new MPInteger[3] { mPInteger3, mPInteger4, mPInteger5 }; return; } case PublicKeyAlgorithmTag.ECDsa: { MPInteger mPInteger = new MPInteger(bcpgIn); MPInteger mPInteger2 = new MPInteger(bcpgIn); signature = new MPInteger[2] { mPInteger, mPInteger2 }; return; } } if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) { signature = null; MemoryStream val = new MemoryStream(); int num3; while ((num3 = ((Stream)bcpgIn).ReadByte()) >= 0) { ((Stream)val).WriteByte((byte)num3); } signatureEncoding = val.ToArray(); return; } throw new IOException(string.Concat((object)"unknown signature key algorithm: ", (object)keyAlgorithm)); }
public SignaturePacket(int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, SignatureSubpacket[] hashedData, SignatureSubpacket[] unhashedData, byte[] fingerprint, MPInteger[] signature) : this(4, signatureType, keyId, keyAlgorithm, hashAlgorithm, hashedData, unhashedData, fingerprint, signature) { }
public PgpSignatureIdentifier(long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { this.mKeyId = keyId; this.mKeyAlgorithm = keyAlgorithm; this.mHashAlgorithm = hashAlgorithm; }
public PgpKeyPair(PublicKeyAlgorithmTag algorithm, AsymmetricCipherKeyPair keyPair, DateTime time) : this(algorithm, keyPair.Public, keyPair.Private, time) { }
public PublicSubkeyPacket(PublicKeyAlgorithmTag algorithm, DateTime time, IBcpgKey key) : base(algorithm, time, key) { }
public PgpPublicKey(PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, DateTime time);
public PgpPublicKey(PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, global::System.DateTime time) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) //IL_016b: Expected O, but got Unknown if (pubKey.IsPrivate) { throw new ArgumentException("Expected a public key", "pubKey"); } IBcpgKey key; if (pubKey is RsaKeyParameters) { RsaKeyParameters rsaKeyParameters = (RsaKeyParameters)pubKey; key = new RsaPublicBcpgKey(rsaKeyParameters.Modulus, rsaKeyParameters.Exponent); } else if (pubKey is DsaPublicKeyParameters) { DsaPublicKeyParameters dsaPublicKeyParameters = (DsaPublicKeyParameters)pubKey; DsaParameters parameters = dsaPublicKeyParameters.Parameters; key = new DsaPublicBcpgKey(parameters.P, parameters.Q, parameters.G, dsaPublicKeyParameters.Y); } else if (pubKey is ECPublicKeyParameters) { ECPublicKeyParameters eCPublicKeyParameters = (ECPublicKeyParameters)pubKey; switch (algorithm) { case PublicKeyAlgorithmTag.EC: key = new ECDHPublicBcpgKey(eCPublicKeyParameters.PublicKeyParamSet, eCPublicKeyParameters.Q, HashAlgorithmTag.Sha256, SymmetricKeyAlgorithmTag.Aes128); break; case PublicKeyAlgorithmTag.ECDsa: key = new ECDsaPublicBcpgKey(eCPublicKeyParameters.PublicKeyParamSet, eCPublicKeyParameters.Q); break; default: throw new PgpException("unknown EC algorithm"); } } else { if (!(pubKey is ElGamalPublicKeyParameters)) { throw new PgpException("unknown key class"); } ElGamalPublicKeyParameters elGamalPublicKeyParameters = (ElGamalPublicKeyParameters)pubKey; ElGamalParameters parameters2 = elGamalPublicKeyParameters.Parameters; key = new ElGamalPublicBcpgKey(parameters2.P, parameters2.G, elGamalPublicKeyParameters.Y); } publicPk = new PublicKeyPacket(algorithm, time, key); ids = Platform.CreateArrayList(); idSigs = Platform.CreateArrayList(); try { Init(); } catch (IOException val) { IOException exception = val; throw new PgpException("exception calculating keyId", (global::System.Exception)(object) exception); } }
public PgpSignatureTypeIdentifier(PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm) { this.mKeyAlgorithm = keyAlgorithm; this.mHashAlgorithm = hashAlgorithm; }
public SignaturePacket(int version, int signatureType, long keyId, PublicKeyAlgorithmTag keyAlgorithm, HashAlgorithmTag hashAlgorithm, long creationTime, byte[] fingerprint, MPInteger[] signature) : this(version, signatureType, keyId, keyAlgorithm, hashAlgorithm, null, null, fingerprint, signature) { this.creationTime = creationTime; }
void AddEncryptionKeyPair(PgpKeyRingGenerator keyRingGenerator, KeyGenerationParameters parameters, PublicKeyAlgorithmTag algorithm, DateTime now, long expirationTime, int[] encryptionAlgorithms, int[] digestAlgorithms) { var keyPairGenerator = GeneratorUtilities.GetKeyPairGenerator("RSA"); keyPairGenerator.Init(parameters); var keyPair = new PgpKeyPair(algorithm, keyPairGenerator.GenerateKeyPair(), now); var subpacketGenerator = new PgpSignatureSubpacketGenerator(); subpacketGenerator.SetKeyFlags(false, PgpKeyFlags.CanEncryptCommunications | PgpKeyFlags.CanEncryptStorage); subpacketGenerator.SetPreferredSymmetricAlgorithms(false, encryptionAlgorithms); subpacketGenerator.SetPreferredHashAlgorithms(false, digestAlgorithms); if (expirationTime > 0) { subpacketGenerator.SetKeyExpirationTime(false, expirationTime); subpacketGenerator.SetSignatureExpirationTime(false, expirationTime); } keyRingGenerator.AddSubKey(keyPair, subpacketGenerator.Generate(), null); }
public PublicSubkeyPacket(PublicKeyAlgorithmTag algorithm, global::System.DateTime time, IBcpgKey key) : base(algorithm, time, key) { }
internal SignaturePacket( BcpgInputStream bcpgIn) { version = bcpgIn.ReadByte(); if (version == 3 || version == 2) { // int l = bcpgIn.ReadByte(); signatureType = bcpgIn.ReadByte(); creationTime = (((long)bcpgIn.ReadByte() << 24) | ((long)bcpgIn.ReadByte() << 16) | ((long)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte()) * 1000L; keyId |= (long)bcpgIn.ReadByte() << 56; keyId |= (long)bcpgIn.ReadByte() << 48; keyId |= (long)bcpgIn.ReadByte() << 40; keyId |= (long)bcpgIn.ReadByte() << 32; keyId |= (long)bcpgIn.ReadByte() << 24; keyId |= (long)bcpgIn.ReadByte() << 16; keyId |= (long)bcpgIn.ReadByte() << 8; keyId |= (uint)bcpgIn.ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); } else if (version == 4) { signatureType = bcpgIn.ReadByte(); keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); int hashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); byte[] hashed = new byte[hashedLength]; bcpgIn.ReadFully(hashed); // // read the signature sub packet data. // SignatureSubpacketsParser sIn = new SignatureSubpacketsParser( new MemoryStream(hashed, false)); IList v = Platform.CreateArrayList(); SignatureSubpacket sub; while ((sub = sIn.ReadPacket()) != null) { v.Add(sub); } hashedData = new SignatureSubpacket[v.Count]; for (int i = 0; i != hashedData.Length; i++) { SignatureSubpacket p = (SignatureSubpacket)v[i]; if (p is IssuerKeyId) { keyId = ((IssuerKeyId)p).KeyId; } else if (p is SignatureCreationTime) { creationTime = DateTimeUtilities.DateTimeToUnixMs( ((SignatureCreationTime)p).GetTime()); } hashedData[i] = p; } int unhashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); byte[] unhashed = new byte[unhashedLength]; bcpgIn.ReadFully(unhashed); sIn = new SignatureSubpacketsParser(new MemoryStream(unhashed, false)); v.Clear(); while ((sub = sIn.ReadPacket()) != null) { v.Add(sub); } unhashedData = new SignatureSubpacket[v.Count]; for (int i = 0; i != unhashedData.Length; i++) { SignatureSubpacket p = (SignatureSubpacket)v[i]; if (p is IssuerKeyId) { keyId = ((IssuerKeyId)p).KeyId; } unhashedData[i] = p; } } else { throw new Exception("unsupported version: " + version); } fingerprint = new byte[2]; bcpgIn.ReadFully(fingerprint); switch (keyAlgorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: MPInteger v = new MPInteger(bcpgIn); signature = new MPInteger[] { v }; break; case PublicKeyAlgorithmTag.Dsa: MPInteger r = new MPInteger(bcpgIn); MPInteger s = new MPInteger(bcpgIn); signature = new MPInteger[] { r, s }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: // yep, this really does happen sometimes. case PublicKeyAlgorithmTag.ElGamalGeneral: MPInteger p = new MPInteger(bcpgIn); MPInteger g = new MPInteger(bcpgIn); MPInteger y = new MPInteger(bcpgIn); signature = new MPInteger[] { p, g, y }; break; case PublicKeyAlgorithmTag.ECDsa: MPInteger ecR = new MPInteger(bcpgIn); MPInteger ecS = new MPInteger(bcpgIn); signature = new MPInteger[] { ecR, ecS }; break; default: if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) { signature = null; MemoryStream bOut = new MemoryStream(); int ch; while ((ch = bcpgIn.ReadByte()) >= 0) { bOut.WriteByte((byte)ch); } signatureEncoding = bOut.ToArray(); } else { throw new IOException("unknown signature key algorithm: " + keyAlgorithm); } break; } }
/// <summary> /// Create a PgpPublicKey from the passed in lightweight one. /// </summary> /// <remarks> /// Note: the time passed in affects the value of the key's keyId, so you probably only want /// to do this once for a lightweight key, or make sure you keep track of the time you used. /// </remarks> /// <param name="algorithm">Asymmetric algorithm type representing the public key.</param> /// <param name="pubKey">Actual public key to associate.</param> /// <param name="time">Date of creation.</param> /// <exception cref="ArgumentException">If <c>pubKey</c> is not public.</exception> /// <exception cref="PgpException">On key creation problem.</exception> public PgpPublicKey( PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, DateTime time) { if (pubKey.IsPrivate) { throw new ArgumentException("Expected a public key", "pubKey"); } IBcpgKey bcpgKey; if (pubKey is RsaKeyParameters) { RsaKeyParameters rK = (RsaKeyParameters)pubKey; bcpgKey = new RsaPublicBcpgKey(rK.Modulus, rK.Exponent); } else if (pubKey is DsaPublicKeyParameters) { DsaPublicKeyParameters dK = (DsaPublicKeyParameters)pubKey; DsaParameters dP = dK.Parameters; bcpgKey = new DsaPublicBcpgKey(dP.P, dP.Q, dP.G, dK.Y); } else if (pubKey is ECPublicKeyParameters) { ECPublicKeyParameters ecK = (ECPublicKeyParameters)pubKey; if (algorithm == PublicKeyAlgorithmTag.ECDH) { bcpgKey = new ECDHPublicBcpgKey(ecK.PublicKeyParamSet, ecK.Q, HashAlgorithmTag.Sha256, SymmetricKeyAlgorithmTag.Aes128); } else if (algorithm == PublicKeyAlgorithmTag.ECDsa) { bcpgKey = new ECDsaPublicBcpgKey(ecK.PublicKeyParamSet, ecK.Q); } else { throw new PgpException("unknown EC algorithm"); } } else if (pubKey is ElGamalPublicKeyParameters) { ElGamalPublicKeyParameters eK = (ElGamalPublicKeyParameters)pubKey; ElGamalParameters eS = eK.Parameters; bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y); } else { throw new PgpException("unknown key class"); } this.publicPk = new PublicKeyPacket(algorithm, time, bcpgKey); this.ids = Platform.CreateArrayList(); this.idSigs = Platform.CreateArrayList(); try { Init(); } catch (IOException e) { throw new PgpException("exception calculating keyId", e); } }
/// <summary> /// Sets revocation key sub packet /// </summary> public void SetRevocationKey(bool isCritical, PublicKeyAlgorithmTag keyAlgorithm, byte[] fingerprint) { list.Add(new RevocationKey(isCritical, RevocationKeyTag.ClassDefault, keyAlgorithm, fingerprint)); }
/// <summary> /// Create master signing key. /// </summary> /// <param name="identity"> /// Identity of the key. /// </param> /// <param name="password"> /// Password to protect the secret key. /// </param> /// <param name="expires"> /// Key expiry; null means never expires. /// </param> /// <param name="signKeyLength"> /// Length of the signing key. /// </param> /// <param name="signGenerator"> /// Generator for the signing key. /// </param> /// <param name="signingAlgorithm"> /// Signing algorithm. /// </param> /// <param name="symmetricAlgorithm"> /// Symmetric algorithm. /// </param> /// <returns> /// Returns the <see cref="PgpKeyRingGenerator"/> with the keyring properties /// thus far. /// </returns> public static PgpKeyRingGenerator CreateMasterSigningKey( string identity, string password, DateTime?expires, int signKeyLength = 2048, string signGenerator = "RSA", PublicKeyAlgorithmTag signingAlgorithm = PublicKeyAlgorithmTag.RsaSign, SymmetricKeyAlgorithmTag symmetricAlgorithm = SymmetricKeyAlgorithmTag.Aes256) { var keyringParameters = new KeyRingParameters(signKeyLength, signGenerator) { Password = password, Identity = identity, PrivateKeyEncryptionAlgorithm = symmetricAlgorithm, SymmetricAlgorithms = new[] { SymmetricKeyAlgorithmTag.Aes256, SymmetricKeyAlgorithmTag.Aes192, SymmetricKeyAlgorithmTag.Aes128 }, HashAlgorithms = new[] { HashAlgorithmTag.Sha256, HashAlgorithmTag.Sha1, HashAlgorithmTag.Sha384, HashAlgorithmTag.Sha512, HashAlgorithmTag.Sha224, } }; // master signing key var generator = GeneratorUtilities.GetKeyPairGenerator(signGenerator); generator.Init(keyringParameters.KeyParams); var masterKeyPair = new PgpKeyPair(signingAlgorithm, generator.GenerateKeyPair(), DateTime.UtcNow); Debug.WriteLine("Generated master key with ID " + masterKeyPair.KeyId.ToString("X")); var symmetricAlgorithms = (from a in keyringParameters.SymmetricAlgorithms select(int) a).ToArray(); var hashAlgorithms = (from a in keyringParameters.HashAlgorithms select(int) a).ToArray(); var masterSubpckGen = new PgpSignatureSubpacketGenerator(); masterSubpckGen.SetKeyFlags(false, PgpKeyFlags.CanSign | PgpKeyFlags.CanCertify); masterSubpckGen.SetPreferredSymmetricAlgorithms(false, symmetricAlgorithms); masterSubpckGen.SetPreferredHashAlgorithms(false, hashAlgorithms); if (expires != null) { masterSubpckGen.SetKeyExpirationTime(false, (long)((DateTime)expires - DateTime.Now).TotalSeconds); } // keyring -- adding master key return(new PgpKeyRingGenerator( PgpSignature.DefaultCertification, masterKeyPair, keyringParameters.Identity, keyringParameters.PrivateKeyEncryptionAlgorithm, keyringParameters.GetPassword(), true, masterSubpckGen.Generate(), null, new SecureRandom())); }
/// <summary> /// Export the public/private keypair. /// </summary> /// <param name="secretPath"> /// The secret output path. /// </param> /// <param name="publicPath"> /// The public output path. /// </param> /// <param name="publicKey"> /// The public key. /// </param> /// <param name="privateKey"> /// The private key. /// </param> /// <param name="identity"> /// The identity for the key. /// </param> /// <param name="passPhrase"> /// The pass phrase for the secret key file. /// </param> /// <param name="creationDate"> /// Date/time the key was created. /// </param> /// <param name="publicKeyAlgorithm"> /// The public key algorithm. /// </param> /// <param name="symmetricAlgorithm"> /// The symmetric key algorithm. /// </param> /// <param name="armor"> /// Should the keys be written using ASCII armor? /// </param> /// <returns> /// The <see cref="PgpSecretKey"/>. /// </returns> public static PgpSecretKey ExportKeyPair( string secretPath, string publicPath, AsymmetricKeyParameter publicKey, AsymmetricKeyParameter privateKey, string identity, char[] passPhrase, DateTime creationDate, PublicKeyAlgorithmTag publicKeyAlgorithm = PublicKeyAlgorithmTag.RsaGeneral, SymmetricKeyAlgorithmTag symmetricAlgorithm = SymmetricKeyAlgorithmTag.Aes256, bool armor = true) { var secretKey = new PgpSecretKey( PgpSignature.DefaultCertification, publicKeyAlgorithm, publicKey, privateKey, creationDate, identity, symmetricAlgorithm, passPhrase, null, null, new SecureRandom()); if (secretPath != null) { using (var secretOut = (Stream) new FileInfo(secretPath).OpenWrite()) { var secretOutputStream = secretOut; if (armor) { secretOutputStream = new ArmoredOutputStream(secretOut); } secretKey.Encode(secretOutputStream); secretOutputStream.Flush(); if (armor) { secretOutputStream.Dispose(); } } } if (publicPath != null) { using (var publicOut = (Stream) new FileInfo(publicPath).OpenWrite()) { var publicOutputStream = publicOut; if (armor) { publicOutputStream = new ArmoredOutputStream(publicOut); } var key = secretKey.PublicKey; key.Encode(publicOutputStream); publicOutputStream.Flush(); if (armor) { publicOutputStream.Dispose(); } } } return(secretKey); }
private void doTestTextSigV3( PublicKeyAlgorithmTag encAlgorithm, HashAlgorithmTag hashAlgorithm, IPgpPublicKey pubKey, IPgpPrivateKey privKey, byte[] data, byte[] canonicalData) { PgpV3SignatureGenerator sGen = new PgpV3SignatureGenerator(encAlgorithm, HashAlgorithmTag.Sha1); MemoryStream bOut = new MemoryStream(); MemoryStream testIn = new MemoryStream(data, false); sGen.InitSign(PgpSignature.CanonicalTextDocument, privKey); sGen.GenerateOnePassVersion(false).Encode(bOut); PgpLiteralDataGenerator lGen = new PgpLiteralDataGenerator(); Stream lOut = lGen.Open( new UncloseableStream(bOut), PgpLiteralData.Text, "_CONSOLE", data.Length * 2, DateTime.UtcNow); int ch; while ((ch = testIn.ReadByte()) >= 0) { lOut.WriteByte((byte)ch); sGen.Update((byte)ch); } lOut.Write(data, 0, data.Length); sGen.Update(data); lGen.Close(); PgpSignature sig = sGen.Generate(); if (sig.CreationTime == DateTimeUtilities.UnixMsToDateTime(0)) { Fail("creation time not set in v3 signature"); } sig.Encode(bOut); verifySignature(bOut.ToArray(), hashAlgorithm, pubKey, canonicalData); }
public PgpKeyPair(PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, AsymmetricKeyParameter privKey, DateTime time) { pub = new PgpPublicKey(algorithm, pubKey, time); priv = new PgpPrivateKey(pub.KeyId, pub.PublicKeyPacket, privKey); }
public PublicKeyEncSessionPacket(long keyId, PublicKeyAlgorithmTag algorithm, BigInteger[] data) : this(keyId, algorithm, data, null) { }
public PgpSecretKey(int certificationLevel, PublicKeyAlgorithmTag algorithm, AsymmetricKeyParameter pubKey, AsymmetricKeyParameter privKey, global::System.DateTime time, string id, SymmetricKeyAlgorithmTag encAlgorithm, char[] passPhrase, bool useSha1, PgpSignatureSubpacketVector hashedPackets, PgpSignatureSubpacketVector unhashedPackets, SecureRandom rand) : this(certificationLevel, new PgpKeyPair(algorithm, pubKey, privKey, time), id, encAlgorithm, passPhrase, useSha1, hashedPackets, unhashedPackets, rand) { }
private byte[] generateV3BinarySig( IPgpPrivateKey privKey, PublicKeyAlgorithmTag encAlgorithm, HashAlgorithmTag hashAlgorithm) { MemoryStream bOut = new MemoryStream(); MemoryStream testIn = new MemoryStream(TEST_DATA, false); PgpV3SignatureGenerator sGen = new PgpV3SignatureGenerator(encAlgorithm, hashAlgorithm); sGen.InitSign(PgpSignature.BinaryDocument, privKey); sGen.GenerateOnePassVersion(false).Encode(bOut); PgpLiteralDataGenerator lGen = new PgpLiteralDataGenerator(); Stream lOut = lGen.Open( new UncloseableStream(bOut), PgpLiteralData.Binary, "_CONSOLE", TEST_DATA.Length * 2, DateTime.UtcNow); int ch; while ((ch = testIn.ReadByte()) >= 0) { lOut.WriteByte((byte)ch); sGen.Update((byte)ch); } lOut.Write(TEST_DATA, 0, TEST_DATA.Length); sGen.Update(TEST_DATA); lGen.Close(); sGen.Generate().Encode(bOut); return bOut.ToArray(); }
internal SignaturePacket(BcpgInputStream bcpgIn) { _version = bcpgIn.ReadByte(); //TODO: refactor switch (_version) { case 2: case 3: bcpgIn.ReadByte(); _signatureType = bcpgIn.ReadByte(); CreationTime = (((long)bcpgIn.ReadByte() << 24) | ((long)bcpgIn.ReadByte() << 16) | ((long)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte()) * 1000L; _keyId |= (long)bcpgIn.ReadByte() << 56; _keyId |= (long)bcpgIn.ReadByte() << 48; _keyId |= (long)bcpgIn.ReadByte() << 40; _keyId |= (long)bcpgIn.ReadByte() << 32; _keyId |= (long)bcpgIn.ReadByte() << 24; _keyId |= (long)bcpgIn.ReadByte() << 16; _keyId |= (long)bcpgIn.ReadByte() << 8; _keyId |= (uint)bcpgIn.ReadByte(); _keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); _hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); break; case 4: { _signatureType = bcpgIn.ReadByte(); _keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte(); _hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte(); var hashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); var hashed = new byte[hashedLength]; bcpgIn.ReadFully(hashed); // // read the signature sub packet data. // using (var hashedStream = new MemoryStream(hashed, false)) { var sIn = new SignatureSubpacketsParser(hashedStream); var v = Platform.CreateArrayList <ISignatureSubpacket>(); SignatureSubpacket sub; while ((sub = sIn.ReadPacket()) != null) { v.Add(sub); var issuerKeyId = sub as IssuerKeyId; if (issuerKeyId != null) { _keyId = issuerKeyId.KeyId; } else { var signatureCreationTime = sub as SignatureCreationTime; if (signatureCreationTime != null) { CreationTime = DateTimeUtilities.DateTimeToUnixMs(signatureCreationTime.GetTime()); } } } _hashedData = v.ToArray(); var unhashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte(); var unhashed = new byte[unhashedLength]; bcpgIn.ReadFully(unhashed); v.Clear(); using (var unhashedStream = new MemoryStream(unhashed, false)) { sIn = new SignatureSubpacketsParser(unhashedStream); while ((sub = sIn.ReadPacket()) != null) { v.Add(sub); var issuerKeyId = sub as IssuerKeyId; if (issuerKeyId != null) { _keyId = issuerKeyId.KeyId; } } } _unhashedData = v.ToArray(); } } break; default: throw new Exception("unsupported version: " + _version); } _fingerprint = new byte[2]; bcpgIn.ReadFully(_fingerprint); switch (_keyAlgorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaSign: var v = new MPInteger(bcpgIn); _signature = new[] { v }; break; case PublicKeyAlgorithmTag.Dsa: case PublicKeyAlgorithmTag.Ecdsa: case PublicKeyAlgorithmTag.Ecdh: var r = new MPInteger(bcpgIn); var s = new MPInteger(bcpgIn); _signature = new[] { r, s }; break; case PublicKeyAlgorithmTag.ElGamalEncrypt: // yep, this really does happen sometimes. case PublicKeyAlgorithmTag.ElGamalGeneral: var p = new MPInteger(bcpgIn); var g = new MPInteger(bcpgIn); var y = new MPInteger(bcpgIn); _signature = new[] { p, g, y }; break; default: if (_keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && _keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11) { _signature = null; using (var bOut = new MemoryStream()) { int ch; while ((ch = bcpgIn.ReadByte()) >= 0) { bOut.WriteByte((byte)ch); } _signatureEncoding = bOut.ToArray(); } } else { throw new IOException("unknown signature key algorithm: " + _keyAlgorithm); } break; } }