public static byte[] CreateKey(PublicKeyPacket pubKeyData, ECPoint s) { byte[] parameters = CreateUserKeyingMaterial(pubKeyData); ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)pubKeyData.Key; return(Kdf(eCDHPublicBcpgKey.HashAlgorithm, s, GetKeyLength(eCDHPublicBcpgKey.SymmetricKeyAlgorithm), parameters)); }
/// <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> /// 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); } }
private byte[] EncryptSessionInfo(byte[] sessionInfo, SecureRandom random) { if (pubKey.Algorithm != PublicKeyAlgorithmTag.EC) { IBufferedCipher cipher; switch (pubKey.Algorithm) { case PublicKeyAlgorithmTag.RsaGeneral: case PublicKeyAlgorithmTag.RsaEncrypt: cipher = CipherUtilities.GetCipher("RSA//PKCS1Padding"); break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: cipher = CipherUtilities.GetCipher("ElGamal/ECB/PKCS1Padding"); break; case PublicKeyAlgorithmTag.Dsa: throw new PgpException("Can't use DSA for encryption."); case PublicKeyAlgorithmTag.ECDsa: throw new PgpException("Can't use ECDSA for encryption."); default: throw new PgpException(string.Concat((object)"unknown asymmetric algorithm: ", (object)pubKey.Algorithm)); } AsymmetricKeyParameter parameters = pubKey.GetKey(); cipher.Init(forEncryption: true, new ParametersWithRandom(parameters, random)); return(cipher.DoFinal(sessionInfo)); } ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)pubKey.PublicKeyPacket.Key; IAsymmetricCipherKeyPairGenerator keyPairGenerator = GeneratorUtilities.GetKeyPairGenerator("ECDH"); keyPairGenerator.Init(new ECKeyGenerationParameters(eCDHPublicBcpgKey.CurveOid, random)); AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.GenerateKeyPair(); ECPrivateKeyParameters eCPrivateKeyParameters = (ECPrivateKeyParameters)asymmetricCipherKeyPair.Private; ECPublicKeyParameters eCPublicKeyParameters = (ECPublicKeyParameters)asymmetricCipherKeyPair.Public; ECPublicKeyParameters eCPublicKeyParameters2 = (ECPublicKeyParameters)pubKey.GetKey(); ECPoint s = eCPublicKeyParameters2.Q.Multiply(eCPrivateKeyParameters.D).Normalize(); KeyParameter parameters2 = new KeyParameter(Rfc6637Utilities.CreateKey(pubKey.PublicKeyPacket, s)); IWrapper wrapper = PgpUtilities.CreateWrapper(eCDHPublicBcpgKey.SymmetricKeyAlgorithm); wrapper.Init(forWrapping: true, new ParametersWithRandom(parameters2, random)); byte[] array = PgpPad.PadSessionData(sessionInfo); byte[] array2 = wrapper.Wrap(array, 0, array.Length); byte[] encoded = new MPInteger(new BigInteger(1, eCPublicKeyParameters.Q.GetEncoded(compressed: false))).GetEncoded(); byte[] array3 = new byte[encoded.Length + 1 + array2.Length]; global::System.Array.Copy((global::System.Array)encoded, 0, (global::System.Array)array3, 0, encoded.Length); array3[encoded.Length] = (byte)array2.Length; global::System.Array.Copy((global::System.Array)array2, 0, (global::System.Array)array3, encoded.Length + 1, array2.Length); return(array3); }
private byte[] RecoverSessionData(PgpPrivateKey privKey) { byte[][] encSessionKey = keyData.GetEncSessionKey(); if (keyData.Algorithm == PublicKeyAlgorithmTag.EC) { ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)privKey.PublicKeyPacket.Key; X9ECParameters x9ECParameters = ECKeyPairGenerator.FindECCurveByOid(eCDHPublicBcpgKey.CurveOid); byte[] array = encSessionKey[0]; int num = (((array[0] & 0xFF) << 8) + (array[1] & 0xFF) + 7) / 8; byte[] array2 = new byte[num]; global::System.Array.Copy((global::System.Array)array, 2, (global::System.Array)array2, 0, num); byte[] array3 = new byte[array[num + 2]]; global::System.Array.Copy((global::System.Array)array, 2 + num + 1, (global::System.Array)array3, 0, array3.Length); ECPoint eCPoint = x9ECParameters.Curve.DecodePoint(array2); ECPrivateKeyParameters eCPrivateKeyParameters = (ECPrivateKeyParameters)privKey.Key; ECPoint s = eCPoint.Multiply(eCPrivateKeyParameters.D).Normalize(); KeyParameter parameters = new KeyParameter(Rfc6637Utilities.CreateKey(privKey.PublicKeyPacket, s)); IWrapper wrapper = PgpUtilities.CreateWrapper(eCDHPublicBcpgKey.SymmetricKeyAlgorithm); wrapper.Init(forWrapping: false, parameters); return(PgpPad.UnpadSessionData(wrapper.Unwrap(array3, 0, array3.Length))); } IBufferedCipher keyCipher = GetKeyCipher(keyData.Algorithm); try { keyCipher.Init(forEncryption: false, privKey.Key); } catch (InvalidKeyException exception) { throw new PgpException("error setting asymmetric cipher", exception); } if (keyData.Algorithm == PublicKeyAlgorithmTag.RsaEncrypt || keyData.Algorithm == PublicKeyAlgorithmTag.RsaGeneral) { byte[] array4 = encSessionKey[0]; keyCipher.ProcessBytes(array4, 2, array4.Length - 2); } else { ElGamalPrivateKeyParameters elGamalPrivateKeyParameters = (ElGamalPrivateKeyParameters)privKey.Key; int size = (elGamalPrivateKeyParameters.Parameters.P.BitLength + 7) / 8; ProcessEncodedMpi(keyCipher, size, encSessionKey[0]); ProcessEncodedMpi(keyCipher, size, encSessionKey[1]); } try { return(keyCipher.DoFinal()); } catch (global::System.Exception exception2) { throw new PgpException("exception decrypting secret key", exception2); } }
public static byte[] CreateUserKeyingMaterial(PublicKeyPacket pubKeyData) { MemoryStream memoryStream = new MemoryStream(); ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)pubKeyData.Key; byte[] encoded = eCDHPublicBcpgKey.CurveOid.GetEncoded(); memoryStream.Write(encoded, 1, encoded.Length - 1); memoryStream.WriteByte((byte)pubKeyData.Algorithm); memoryStream.WriteByte(3); memoryStream.WriteByte(1); memoryStream.WriteByte((byte)eCDHPublicBcpgKey.HashAlgorithm); memoryStream.WriteByte((byte)eCDHPublicBcpgKey.SymmetricKeyAlgorithm); memoryStream.Write(ANONYMOUS_SENDER, 0, ANONYMOUS_SENDER.Length); byte[] array = PgpPublicKey.CalculateFingerprint(pubKeyData); memoryStream.Write(array, 0, array.Length); return(memoryStream.ToArray()); }
public static string GetAgreementAlgorithm(PublicKeyPacket pubKeyData) { ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)pubKeyData.Key; switch (ecKey.HashAlgorithm) { case HashAlgorithmTag.Sha256: return("ECCDHwithSHA256CKDF"); case HashAlgorithmTag.Sha384: return("ECCDHwithSHA384CKDF"); case HashAlgorithmTag.Sha512: return("ECCDHwithSHA512CKDF"); default: throw new ArgumentException("Unknown hash algorithm specified: " + ecKey.HashAlgorithm); } }
public static byte[] CreateUserKeyingMaterial(PublicKeyPacket pubKeyData) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Expected O, but got Unknown MemoryStream val = new MemoryStream(); ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)pubKeyData.Key; byte[] encoded = eCDHPublicBcpgKey.CurveOid.GetEncoded(); ((Stream)val).Write(encoded, 1, encoded.Length - 1); ((Stream)val).WriteByte((byte)pubKeyData.Algorithm); ((Stream)val).WriteByte((byte)3); ((Stream)val).WriteByte((byte)1); ((Stream)val).WriteByte((byte)eCDHPublicBcpgKey.HashAlgorithm); ((Stream)val).WriteByte((byte)eCDHPublicBcpgKey.SymmetricKeyAlgorithm); ((Stream)val).Write(ANONYMOUS_SENDER, 0, ANONYMOUS_SENDER.Length); byte[] array = PgpPublicKey.CalculateFingerprint(pubKeyData); ((Stream)val).Write(array, 0, array.Length); return(val.ToArray()); }
// RFC 6637 - Section 8 // curve_OID_len = (byte)len(curve_OID); // Param = curve_OID_len || curve_OID || public_key_alg_ID || 03 // || 01 || KDF_hash_ID || KEK_alg_ID for AESKeyWrap || "Anonymous // Sender " || recipient_fingerprint; // Z_len = the key size for the KEK_alg_ID used with AESKeyWrap // Compute Z = KDF( S, Z_len, Param ); public static byte[] CreateUserKeyingMaterial(PublicKeyPacket pubKeyData) { MemoryStream pOut = new MemoryStream(); ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)pubKeyData.Key; byte[] encOid = ecKey.CurveOid.GetEncoded(); pOut.Write(encOid, 1, encOid.Length - 1); pOut.WriteByte((byte)pubKeyData.Algorithm); pOut.WriteByte(0x03); pOut.WriteByte(0x01); pOut.WriteByte((byte)ecKey.HashAlgorithm); pOut.WriteByte((byte)ecKey.SymmetricKeyAlgorithm); pOut.Write(ANONYMOUS_SENDER, 0, ANONYMOUS_SENDER.Length); byte[] fingerprint = PgpPublicKey.CalculateFingerprint(pubKeyData); pOut.Write(fingerprint, 0, fingerprint.Length); return(pOut.ToArray()); }
public static string GetAgreementAlgorithm(PublicKeyPacket pubKeyData) { //IL_0050: Unknown result type (might be due to invalid IL or missing references) ECDHPublicBcpgKey eCDHPublicBcpgKey = (ECDHPublicBcpgKey)pubKeyData.Key; switch (eCDHPublicBcpgKey.HashAlgorithm) { case HashAlgorithmTag.Sha256: return("ECCDHwithSHA256CKDF"); case HashAlgorithmTag.Sha384: return("ECCDHwithSHA384CKDF"); case HashAlgorithmTag.Sha512: return("ECCDHwithSHA512CKDF"); default: throw new ArgumentException(string.Concat((object)"Unknown hash algorithm specified: ", (object)eCDHPublicBcpgKey.HashAlgorithm)); } }
/// <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); } }
private byte[] EncryptSessionInfo(byte[] sessionInfo, SecureRandom random) { if (pubKey.Algorithm != PublicKeyAlgorithmTag.ECDH) { IBufferedCipher c; switch (pubKey.Algorithm) { case PublicKeyAlgorithmTag.RsaEncrypt: case PublicKeyAlgorithmTag.RsaGeneral: c = CipherUtilities.GetCipher("RSA//PKCS1Padding"); break; case PublicKeyAlgorithmTag.ElGamalEncrypt: case PublicKeyAlgorithmTag.ElGamalGeneral: c = CipherUtilities.GetCipher("ElGamal/ECB/PKCS1Padding"); break; case PublicKeyAlgorithmTag.Dsa: throw new PgpException("Can't use DSA for encryption."); case PublicKeyAlgorithmTag.ECDsa: throw new PgpException("Can't use ECDSA for encryption."); default: throw new PgpException("unknown asymmetric algorithm: " + pubKey.Algorithm); } AsymmetricKeyParameter akp = pubKey.GetKey(); c.Init(true, new ParametersWithRandom(akp, random)); return(c.DoFinal(sessionInfo)); } ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)pubKey.PublicKeyPacket.Key; // Generate the ephemeral key pair IAsymmetricCipherKeyPairGenerator gen = GeneratorUtilities.GetKeyPairGenerator("ECDH"); gen.Init(new ECKeyGenerationParameters(ecKey.CurveOid, random)); AsymmetricCipherKeyPair ephKp = gen.GenerateKeyPair(); ECPrivateKeyParameters ephPriv = (ECPrivateKeyParameters)ephKp.Private; ECPublicKeyParameters ephPub = (ECPublicKeyParameters)ephKp.Public; ECPublicKeyParameters pub = (ECPublicKeyParameters)pubKey.GetKey(); ECPoint S = pub.Q.Multiply(ephPriv.D).Normalize(); KeyParameter key = new KeyParameter(Rfc6637Utilities.CreateKey(pubKey.PublicKeyPacket, S)); IWrapper w = PgpUtilities.CreateWrapper(ecKey.SymmetricKeyAlgorithm); w.Init(true, new ParametersWithRandom(key, random)); byte[] paddedSessionData = PgpPad.PadSessionData(sessionInfo); byte[] C = w.Wrap(paddedSessionData, 0, paddedSessionData.Length); byte[] VB = new MPInteger(new BigInteger(1, ephPub.Q.GetEncoded(false))).GetEncoded(); byte[] rv = new byte[VB.Length + 1 + C.Length]; Array.Copy(VB, 0, rv, 0, VB.Length); rv[VB.Length] = (byte)C.Length; Array.Copy(C, 0, rv, VB.Length + 1, C.Length); return(rv); }
private byte[] RecoverSessionData(PgpPrivateKey privKey) { byte[][] secKeyData = keyData.GetEncSessionKey(); if (keyData.Algorithm == PublicKeyAlgorithmTag.ECDH) { ECDHPublicBcpgKey ecKey = (ECDHPublicBcpgKey)privKey.PublicKeyPacket.Key; X9ECParameters x9Params = ECKeyPairGenerator.FindECCurveByOid(ecKey.CurveOid); byte[] enc = secKeyData[0]; int pLen = ((((enc[0] & 0xff) << 8) + (enc[1] & 0xff)) + 7) / 8; byte[] pEnc = new byte[pLen]; Array.Copy(enc, 2, pEnc, 0, pLen); byte[] keyEnc = new byte[enc[pLen + 2]]; Array.Copy(enc, 2 + pLen + 1, keyEnc, 0, keyEnc.Length); ECPoint publicPoint = x9Params.Curve.DecodePoint(pEnc); ECPrivateKeyParameters privKeyParams = (ECPrivateKeyParameters)privKey.Key; ECPoint S = publicPoint.Multiply(privKeyParams.D).Normalize(); KeyParameter key = new KeyParameter(Rfc6637Utilities.CreateKey(privKey.PublicKeyPacket, S)); IWrapper w = PgpUtilities.CreateWrapper(ecKey.SymmetricKeyAlgorithm); w.Init(false, key); return(PgpPad.UnpadSessionData(w.Unwrap(keyEnc, 0, keyEnc.Length))); } IBufferedCipher cipher = GetKeyCipher(keyData.Algorithm); try { cipher.Init(false, privKey.Key); } catch (InvalidKeyException e) { throw new PgpException("error setting asymmetric cipher", e); } if (keyData.Algorithm == PublicKeyAlgorithmTag.RsaEncrypt || keyData.Algorithm == PublicKeyAlgorithmTag.RsaGeneral) { byte[] bi = secKeyData[0]; cipher.ProcessBytes(bi, 2, bi.Length - 2); } else { ElGamalPrivateKeyParameters k = (ElGamalPrivateKeyParameters)privKey.Key; int size = (k.Parameters.P.BitLength + 7) / 8; ProcessEncodedMpi(cipher, size, secKeyData[0]); ProcessEncodedMpi(cipher, size, secKeyData[1]); } try { return(cipher.DoFinal()); } catch (Exception e) { throw new PgpException("exception decrypting secret key", e); } }
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); } }
/// <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); } }