public PgpSignature(PgpPacket FromPacket, PgpPublicKey PublicMasterKeyPacket, PgpPublicKey PublicKeyPacket, EncryptionServices Cryptography) : base(FromPacket)
{
Initialise(nSignatureType.SubkeyBinding);
_PublicKeyPacket = PublicKeyPacket;
_Cryptography = Cryptography;
Parse(PublicMasterKeyPacket);
}
public EncryptedDatabase(string sPath, EncryptionServices Cryptography = null) : base(sPath)
{
_abAesKey = null;
_ltVariables = new List <DatabaseVariable>();
_ltProperties = new List <Property>();
_quVariablesStore = new Queue <DatabaseVariable>();
_Cryptography = Cryptography ?? new EncryptionServices();
}
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;
}
}
}
/// <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 void Initialise()
{
_iDBits = _iPBits = _iQBits = _iInverseQBits = _iOffsetSecretKey = 0;
_eStringToKeyUsage = nStringToKeyUsage.Sha1;
_eSymmetricKeyAlgorithm = nSymmetricKeyAlgorithm.Aes128;
_eStringToKeySpecifier = nStringToKeySpecifier.SaltedAndIterated;
_eHashAlgorithm = nHashAlgorithm.Sha1;
_Cryptography = null;
_PublicKey = null;
_KeyParameters = new RSAParameters();
}
/// <summary></summary>
private void Initialise(nSignatureType eSignatureType)
{
_abFingerprint = _abHashFingerprint = _abSignature = null;
_iHashedLength = _iSignatureBits = 0;
_eVerified = nVerified.Pending;
_eSignatureType = eSignatureType;
_eTranslatedKeyFlags = nTranslatedKeyFlags.None;
_ePublicKeyAlgorithm = nPublicKeyAlgorithm.RsaEncryptOrSign;
_eHashAlgorithm = nHashAlgorithm.Sha512;
_PrivateKeyPacket = null;
_PublicKeyPacket = null;
_UserIdPacket = null;
_Cryptography = null;
_ltSubpackets = new List <PgpSignatureSubpacket>();
}
/// <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;
}
}
public PgpSignature(ISlotInfo SlotInfo, byte[] abId, PgpKeyFlags.nFlags eKeyFlags, byte[] abModulus, byte[] abExponent, EncryptionServices Cryptography) : base(nPacketTag.Signature)
{
PgpSignatureSubpacket NewSubpacket;
Initialise((eKeyFlags & PgpKeyFlags.nFlags.Sign) == 0 ? nSignatureType.SubkeyBinding : nSignatureType.PositiveCertification);
if ((SlotInfo == null) || (abId == null) || (abModulus == null) || (abExponent == null) || (Cryptography == null))
{
_eStatus = nStatus.MissingArgument;
}
else
{
_eStatus = nStatus.OK;
_Cryptography = Cryptography;
_PublicKeyPacket = new PgpPublicKey(SlotInfo, abId, (eKeyFlags & PgpKeyFlags.nFlags.Sign) == 0 ? nPacketTag.PublicSubkey : nPacketTag.PublicKey, DateTime.Now, nPublicKeyAlgorithm.RsaEncryptOrSign, abModulus, abExponent);
NewSubpacket = new PgpKeyFlags(eKeyFlags);
_ltSubpackets.Add(NewSubpacket);
_eTranslatedKeyFlags = TranslateKeyFlags();
}
}
public PgpAesWithCfb(byte[] abKey, byte[] abInitialisationVector, EncryptionServices Cryptography)
{
_abCfbInputVector = _abCfbOutputVector = null;
_Cryptography = Cryptography;
Reset(abKey, abInitialisationVector);
}
/// <summary>Constructor for OpenPGP smard card hardware tokens.</summary>
public PgpToken(ITokenInfo TokenInfo, EncryptionServices Cryptography) : this(Cryptography)
{
_TokenInfo = TokenInfo;
}
private PgpMessage(EncryptionServices Cryptography)
{
_eStatus = nStatus.Undefined;
_Cryptography = Cryptography;
_ltPublicKeyEncryptedKeys = new List <PgpPublicKeyEncryptedKey>();
}
