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;
}
