protected PgpPacketBase(PgpPacketBase FromPacket)
{
_eStatus = FromPacket.eStatus;
_iHeaderLength = FromPacket.iHeaderLength;
_iDataLength = FromPacket.iDataLength;
_abRawBytes = FromPacket.abRawBytes;
}
/// <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>();
}
protected int CountUsedBits(byte[] abLongInteger)
{
int i, j, iReturn;
byte b;
if ((abLongInteger == null) || (abLongInteger.Length == 0))
{
_eStatus = nStatus.ParseError;
iReturn = 0;
}
else
{
iReturn = abLongInteger.Length << 3;
i = 0;
do
{
b = abLongInteger[i++];
if (b == 0)
{
iReturn -= 8;
}
else
{
j = 0;
do
{
if ((b & 0x80) == 0)
{
iReturn--;
b <<= 1;
j++;
}
else
{
j = 8; // end the loop
}
} while (j < 8);
i = abLongInteger.Length; // end the loop
}
} while (i < abLongInteger.Length);
}
return(iReturn);
}
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 PgpMessage(EncryptionServices Cryptography)
{
_eStatus = nStatus.Undefined;
_Cryptography = Cryptography;
_ltPublicKeyEncryptedKeys = new List <PgpPublicKeyEncryptedKey>();
}
/// <summary></summary>
/// <param name=""></param>
/// <param name=""></param>
public byte[] Parse(string sArmor, bool isKey)
{
byte[] abCrc24, abReturn = null;
int i, iCrc24Value;
Crc24 Crc24Computed;
BytesAndTextUtility StringConverter;
nArmorParserState eArmorParserState = nArmorParserState.Start;
string sArmoredData, sChecksum, sHeader;
string[] asLines;
if (string.IsNullOrEmpty(sArmor))
{
_eStatus = nStatus.ParseError;
}
else
{
asLines = sArmor.Split(asDelimiters, StringSplitOptions.None);
sArmoredData = sChecksum = sHeader = string.Empty;
for (i = 0; i < asLines.Length; i++)
{
switch (eArmorParserState)
{
case nArmorParserState.Start:
eArmorParserState = isKey ? ParseCheckForKeyHeader(asLines[i]) : ParseCheckForMessageHeader(asLines[i]);
if (eArmorParserState == nArmorParserState.Header)
{
sHeader = asLines[i];
}
break;
case nArmorParserState.Header:
case nArmorParserState.KeyValue: eArmorParserState = ParseCheckForBlankLine(asLines[i]); break;
case nArmorParserState.BlankLine:
case nArmorParserState.ArmoredData:
eArmorParserState = ParseCheckForData(asLines[i], sHeader);
if (eArmorParserState == nArmorParserState.ArmoredData)
{
sArmoredData += asLines[i];
}
else if (eArmorParserState == nArmorParserState.Checksum)
{
sChecksum = asLines[i];
}
break;
case nArmorParserState.Checksum: eArmorParserState = ParseCheckForFooter(asLines[i], sHeader); break;
}
}
if (eArmorParserState == nArmorParserState.Success)
{
StringConverter = new BytesAndTextUtility(sArmoredData);
abReturn = StringConverter.abBase64StringBytes;
if (abReturn == null)
{
_eStatus = nStatus.ParseError;
}
else
{
_eStatus = nStatus.OK;
if (!string.IsNullOrEmpty(sChecksum))
{
StringConverter = new BytesAndTextUtility(sChecksum.Substring(1));
abCrc24 = StringConverter.abBase64StringBytes;
if ((abCrc24 == null) || (abCrc24.Length != Crc24.ciCrc24Length))
{
_eStatus = nStatus.ParseError;
abReturn = null;
}
else
{
iCrc24Value = (abCrc24[0] << 16) | (abCrc24[1] << 8) | abCrc24[2];
Crc24Computed = new Crc24(abReturn);
if (iCrc24Value != Crc24Computed.iCrc24)
{
_eStatus = nStatus.CrcError;
abReturn = null;
}
}
}
}
}
else
{
_eStatus = nStatus.ParseError;
}
}
return(abReturn);
}
public PgpArmor()
{
_eStatus = nStatus.Undefined;
}
protected PgpPacketBase()
{
_eStatus = nStatus.Undefined;
_iDataLength = _iHeaderLength = 0;
_abRawBytes = null;
}
