private PgpPacket ParseCertificationSignature(PgpPacket RawPgpPacket, List <PgpToken> ltTokens) { PgpSignature ReturnPaket = null; if ((RawPgpPacket != null) && (_KeyPacket != null) && (_UserIdPacket != null) && (_Cryptography != null)) { if ((_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PrivateKey) || (_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PrivateSubkey)) { ReturnPaket = new PgpSignature(RawPgpPacket, (PgpPrivateKey)_KeyPacket, _UserIdPacket, ltTokens, _Cryptography); if ((_KeyPacket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { ((PgpPrivateKey)_KeyPacket).PublicKey.Signature = ReturnPaket; } } else if ((_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PublicKey) || (_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PublicSubkey)) { ReturnPaket = new PgpSignature(RawPgpPacket, (PgpPublicKey)_KeyPacket, _UserIdPacket, ltTokens, _Cryptography); if ((_KeyPacket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { ((PgpPublicKey)_KeyPacket).Signature = ReturnPaket; } } } return(ReturnPaket); }
public PgpSignature(PgpPacket FromPacket, PgpPublicKey PublicMasterKeyPacket, PgpPublicKey PublicKeyPacket, EncryptionServices Cryptography) : base(FromPacket) { Initialise(nSignatureType.SubkeyBinding); _PublicKeyPacket = PublicKeyPacket; _Cryptography = Cryptography; Parse(PublicMasterKeyPacket); }
private PgpPacket ParseSubkeySignature(PgpPacket RawPgpPacket) { PgpSignature ReturnPaket = null; if ((RawPgpPacket != null) && (_ltSubkeys.Count > 0) && (_KeyPacket != null) && (_Cryptography != null)) { if ((_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PrivateKey) || (_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PrivateSubkey)) { ReturnPaket = new PgpSignature(RawPgpPacket, _ltSubkeys[0].PublicKeyPacket, (PgpPrivateKey)_KeyPacket, _Cryptography); if ((_KeyPacket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { ((PgpPrivateKey)_KeyPacket).PublicKey.Signature = ReturnPaket; } } else if ((_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PublicKey) || (_KeyPacket.ePacketTag == PgpPacket.nPacketTag.PublicSubkey)) { ReturnPaket = new PgpSignature(RawPgpPacket, _ltSubkeys[0].PublicKeyPacket, (PgpPublicKey)_KeyPacket, _Cryptography); if ((_KeyPacket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { ((PgpPublicKey)_KeyPacket).Signature = ReturnPaket; } } } return(ReturnPaket); }
public PgpSignature(PgpPacket FromPacket, PgpPublicKey PublicMasterKeyPacket, PgpUserId UserIdPacket, List <PgpToken> ltTokens, EncryptionServices Cryptography) : base(FromPacket) { Initialise(nSignatureType.PositiveCertification); _PublicKeyPacket = PublicMasterKeyPacket; _UserIdPacket = UserIdPacket; _Cryptography = Cryptography; Parse(_PublicKeyPacket, ltTokens); }
/// <summary>Constructor for OpenPGP keyring files.</summary> public PgpToken(byte[] abKeyBytes, List <PgpToken> ltTokens, EncryptionServices Cryptography) : this(Cryptography) { bool isPublicKey = true; int iPgpPacketPointer = 0; PgpPacket DecodedPgpPacket, RawPgpPacket; if (abKeyBytes != null) { _eStatus = nStatus.OK; while ((_eStatus == nStatus.OK) && (iPgpPacketPointer < abKeyBytes.Length - 2)) { RawPgpPacket = new PgpPacket(abKeyBytes, iPgpPacketPointer); if (RawPgpPacket.eStatus == PgpPacketBase.nStatus.OK) { switch (RawPgpPacket.ePacketTag) { case PgpPacket.nPacketTag.PrivateKey: case PgpPacket.nPacketTag.PrivateSubkey: DecodedPgpPacket = ParsePrivateKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.PublicKey: case PgpPacket.nPacketTag.PublicSubkey: DecodedPgpPacket = ParsePublicKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.Signature: DecodedPgpPacket = ParseSignaturePacket(RawPgpPacket, ltTokens); break; case PgpPacket.nPacketTag.UserId: DecodedPgpPacket = ParseUserIdPacket(RawPgpPacket); break; default: DecodedPgpPacket = null; Console.WriteLine("not implemented: ePacketTag=" + RawPgpPacket.ePacketTag.ToString()); break; } if ((DecodedPgpPacket == null) || (DecodedPgpPacket.eStatus != PgpPacketBase.nStatus.OK)) { _eStatus = nStatus.ParseErrorSub; } // else // Console.WriteLine(" Found ePacketTag=" + RawPgpPacket.ePacketTag.ToString() + " iHeaderLength=" + RawPgpPacket.iHeaderLength.ToString() + ", iDataLength=" + RawPgpPacket.iDataLength.ToString()); iPgpPacketPointer += (RawPgpPacket.iHeaderLength + RawPgpPacket.iPartialHeaders + RawPgpPacket.iDataLength); } else { _eStatus = nStatus.ParseErrorRaw; } } if (((_eStatus == nStatus.OK) && (iPgpPacketPointer != abKeyBytes.Length)) || (_ltSubkeys == null) || (_ltSubkeys.Count == 0)) { _eStatus = nStatus.ParseErrorRaw; } else { foreach (PgpSignature Subkey in _ltSubkeys) { isPublicKey = isPublicKey && (Subkey.PrivateKeyPacket == null); // one private key packet flags the whole token as private } _eType = isPublicKey ? nType.Public : nType.Private; } } }
public PgpPublicKeyEncryptedKey(PgpPacket FromPacket) : base(FromPacket) { _abEncryptedKey = _abPublicKeyId = null; _iEncryptedKeyBits = 0; _sUserId = string.Empty; _ePublicKeyAlgorithm = nPublicKeyAlgorithm.RsaEncryptOrSign; _MatchedPublicKey = null; Parse(); }
/// <summary>Base constructor for initialisation.</summary> private PgpToken(EncryptionServices Cryptography) { _eStatus = nStatus.Undefined; _eType = nType.Undefined; _sSlotName = string.Empty; _TokenInfo = null; _UserIdPacket = null; _Cryptography = Cryptography; _KeyPacket = null; _ltSubkeys = new List <PgpSignature>(); }
/// <summary></summary> private PgpPacket ParsePublicKeyEncryptedKeyPacket(PgpPacket RawPgpPacket) { PgpPublicKeyEncryptedKey ReturnPaket = new PgpPublicKeyEncryptedKey(RawPgpPacket); if (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK) { _ltPublicKeyEncryptedKeys.Add(ReturnPaket); } return(ReturnPaket); }
public PgpUserId(PgpPacket FromPacket) : base(FromPacket) { if ((_abRawBytes == null) || (_abRawBytes.Length < _iHeaderLength) || (_ePacketTag != nPacketTag.UserId)) { _eStatus = nStatus.ParseError; } else if (_eStatus == nStatus.OK) { _sUserId = Encoding.UTF8.GetString(_abRawBytes, _iHeaderLength, _abRawBytes.Length - _iHeaderLength); SplitUserId(); } }
private PgpPacket ParsePublicKeyPacket(PgpPacket RawPgpPacket) { PgpPacket ReturnPaket = new PgpPublicKey(RawPgpPacket); if ((ReturnPaket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK) && ((ReturnPaket.ePacketTag == PgpPacket.nPacketTag.PublicKey) || (ReturnPaket.ePacketTag == PgpPacket.nPacketTag.PublicSubkey))) { _KeyPacket = ReturnPaket; } else { _KeyPacket = null; } return(ReturnPaket); }
public PgpPublicKey(PgpPacket FromPacket) : base(FromPacket) { PgpPublicKeyUtility KeyUtility; Initialise(); KeyUtility = new PgpPublicKeyUtility(_abRawBytes); _eStatus = KeyUtility.eStatus; if (_eStatus == nStatus.OK) { _Created = KeyUtility.Created; _ePublicKeyAlgorithm = KeyUtility.ePublicKeyAlgorithm; InitialiseKeyParameters(KeyUtility.abModulus, KeyUtility.abExponent); } }
private PgpPacket ParseUserIdPacket(PgpPacket RawPgpPacket) { PgpPacket ReturnPaket = null; if (_UserIdPacket == null) { ReturnPaket = new PgpUserId(RawPgpPacket); if ((ReturnPaket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { _UserIdPacket = (PgpUserId)ReturnPaket; } } return(ReturnPaket); }
/// <summary></summary> public PgpPrivateKey(PgpPacket FromPacket, EncryptionServices Cryptography) : base(FromPacket) { PgpPublicKeyUtility KeyUtility; Initialise(); _Cryptography = Cryptography; KeyUtility = new PgpPublicKeyUtility(_abRawBytes); // extract the public key bytes _eStatus = KeyUtility.eStatus; if (_eStatus == nStatus.OK) { _PublicKey = new PgpPublicKey(new PgpPacket(KeyUtility.abRawBytes, 0)); // and turn them into a public key _KeyParameters.Exponent = KeyUtility.abExponent; _KeyParameters.Modulus = KeyUtility.abModulus; _eStatus = _PublicKey.eStatus; if (_eStatus == nStatus.OK) { _iOffsetSecretKey = _PublicKey.iHeaderLength + _PublicKey.iDataLength; _eStringToKeyUsage = (nStringToKeyUsage)_abRawBytes[_iOffsetSecretKey++]; if ((_eStringToKeyUsage == nStringToKeyUsage.Sha1) || (_eStringToKeyUsage == nStringToKeyUsage.Checksum)) { _eSymmetricKeyAlgorithm = (nSymmetricKeyAlgorithm)_abRawBytes[_iOffsetSecretKey++]; _eStringToKeySpecifier = (nStringToKeySpecifier)_abRawBytes[_iOffsetSecretKey++]; _eHashAlgorithm = (nHashAlgorithm)_abRawBytes[_iOffsetSecretKey++]; if ((_eSymmetricKeyAlgorithm == nSymmetricKeyAlgorithm.Unencrypted) || (_eSymmetricKeyAlgorithm == nSymmetricKeyAlgorithm.Aes128)) { if (_eStringToKeySpecifier == nStringToKeySpecifier.GnuDummy) { throw new NotImplementedException("eStringToKeySpecifier == nStringToKeySpecifier.GnuDummy"); } } else { _eStatus = nStatus.AlgorithmNotSupported; } } else { _eStatus = nStatus.AlgorithmNotSupported; } } } }
public PgpMessage(byte[] abMessageBytes, EncryptionServices Cryptography) : this(Cryptography) { int iPgpPacketPointer = 0; PgpPacket DecodedPgpPacket, RawPgpPacket; if (abMessageBytes != null) { _eStatus = nStatus.OK; while ((_eStatus == nStatus.OK) && (iPgpPacketPointer < abMessageBytes.Length - 2)) { RawPgpPacket = new PgpPacket(abMessageBytes, iPgpPacketPointer); if (RawPgpPacket.eStatus == PgpPacketBase.nStatus.OK) { switch (RawPgpPacket.ePacketTag) { case PgpPacket.nPacketTag.PublicKeyEncryptedKey: DecodedPgpPacket = ParsePublicKeyEncryptedKeyPacket(RawPgpPacket); break; case PgpPacket.nPacketTag.SymmetricallyEncryptedProtected: DecodedPgpPacket = new PgpSymmetricallyEncryptedDataPacket(RawPgpPacket); break; default: DecodedPgpPacket = null; Console.WriteLine("not implemented: ePacketTag=" + RawPgpPacket.ePacketTag.ToString()); break; } if ((DecodedPgpPacket == null) || (DecodedPgpPacket.eStatus != PgpPacketBase.nStatus.OK)) { _eStatus = nStatus.ParseErrorSub; } iPgpPacketPointer += (RawPgpPacket.iHeaderLength + RawPgpPacket.iPartialHeaders + RawPgpPacket.iDataLength); } else { _eStatus = nStatus.ParseErrorRaw; } } } if (((_eStatus == nStatus.OK) && (iPgpPacketPointer != abMessageBytes.Length))) { _eStatus = nStatus.ParseErrorRaw; } }
private PgpPacket ParseSignaturePacket(PgpPacket RawPgpPacket, List <PgpToken> ltTokens) { PgpPacket ReturnPaket = null; PgpPacketBase.nSignatureType ePreviewSignatureType = (PgpPacketBase.nSignatureType)RawPgpPacket.abRawBytes[RawPgpPacket.iHeaderLength + 1]; switch (ePreviewSignatureType) { case PgpPacketBase.nSignatureType.GenericCertification: case PgpPacketBase.nSignatureType.PersonaCertification: case PgpPacketBase.nSignatureType.CasualCertification: case PgpPacketBase.nSignatureType.PositiveCertification: ReturnPaket = ParseCertificationSignature(RawPgpPacket, ltTokens); break; case PgpPacketBase.nSignatureType.SubkeyBinding: ReturnPaket = ParseSubkeySignature(RawPgpPacket); break; } if ((ReturnPaket != null) && (ReturnPaket.eStatus == PgpPacketBase.nStatus.OK)) { _ltSubkeys.Add((PgpSignature)ReturnPaket); } return(ReturnPaket); }
public PgpSymmetricallyEncryptedDataPacket(PgpPacket FromPacket) : base(FromPacket) { }
protected PgpPacket(PgpPacket FromPacket) : base(FromPacket) { _isNewPacketFormat = FromPacket.isNewPacketFormat; _ePacketTag = FromPacket.ePacketTag; _iPartialHeaders = FromPacket.iPartialHeaders; }