public PgpPublicKey(ISlotInfo SlotInfo, byte[] abId, nPacketTag ePacketTag, DateTime Created, nPublicKeyAlgorithm ePublicKeyAlgorithm, byte[] abModulus, byte[] abExponent) : this(ePacketTag)
{
_SlotInfo = SlotInfo;
_abId = abId;
_Created = Created;
_ePublicKeyAlgorithm = ePublicKeyAlgorithm;
InitialiseKeyParameters(abModulus, abExponent);
EncodeRawBytes();
}
public PgpPublicKeyUtility(nPacketTag ePacketTag, DateTime Created, nPublicKeyAlgorithm ePublicKeyAlgorithm, byte[] abModulus, byte[] abExponent) : base(ePacketTag)
{
_eStatus = nStatus.OK;
_Created = Created;
_ePublicKeyAlgorithm = ePublicKeyAlgorithm;
_iModulusBits = CountUsedBits(abModulus);
_iExponentBits = CountUsedBits(abExponent);
_abModulus = abModulus;
_abExponent = abExponent;
EncodeRawBytes();
}
public PgpPacket(byte[] abPaketBytes, int iOffset) : this(nPacketTag.Reserved)
{
byte bLengthByte, bPacketTag;
bool isPartialLength;
int i, j, k, iPacketType, iPartialDataLength = 0;
int[] aiNewPartialHeaderOffsets, aiPartialHeaderOffsets = null;
if ((abPaketBytes == null) || (iOffset >= abPaketBytes.Length - 4))
{
_eStatus = nStatus.ParseError;
}
else
{
bPacketTag = abPaketBytes[iOffset];
if ((bPacketTag & cbPacketTagMask) == 0)
{
_eStatus = nStatus.InvalidPacketTag;
}
else
{
_eStatus = nStatus.OK;
_isNewPacketFormat = ((bPacketTag & cbNewPacketFormatMask) != 0);
do
{
isPartialLength = false;
if (_isNewPacketFormat)
{
iPacketType = (bPacketTag & cbNewPacketFormatPacketTagMask);
if (iOffset + iPartialDataLength + 6 > abPaketBytes.Length)
{
bLengthByte = 0;
_eStatus = nStatus.ParseError;
}
else
{
bLengthByte = abPaketBytes[iOffset + iPartialDataLength + 1];
}
if (bLengthByte < cbSmallestTwoByteLengthNew)
{
_iDataLength = bLengthByte;
_iHeaderLength = 2;
}
else if (bLengthByte < 0xe0)
{
_iDataLength = ((bLengthByte - cbSmallestTwoByteLengthNew) << 8) + abPaketBytes[iOffset + iPartialDataLength + 2] + cbSmallestTwoByteLengthNew;
_iHeaderLength = 3;
}
else if (bLengthByte == 0xff)
{
_iDataLength = abPaketBytes[iOffset + iPartialDataLength + 2] << 24 | abPaketBytes[iOffset + iPartialDataLength + 3] << 16 | abPaketBytes[iOffset + iPartialDataLength + 4] << 8 | abPaketBytes[iOffset + iPartialDataLength + 5];
_iHeaderLength = 6;
}
else
{
isPartialLength = true;
_iDataLength = 1 << (bLengthByte & 0x1f);
if (aiPartialHeaderOffsets == null)
{
aiPartialHeaderOffsets = new int[1];
}
else
{
aiNewPartialHeaderOffsets = new int[aiPartialHeaderOffsets.Length + 1];
for (i = 0; i < aiPartialHeaderOffsets.Length; i++)
{
aiNewPartialHeaderOffsets[i] = aiPartialHeaderOffsets[i];
}
aiPartialHeaderOffsets = aiNewPartialHeaderOffsets;
}
aiPartialHeaderOffsets[aiPartialHeaderOffsets.Length - 1] = iPartialDataLength;
}
}
else
{
iPacketType = (bPacketTag & cbOldPacketFormatPacketTagMask) >> 2;
switch (bPacketTag & cbOldPacketFormatLengthTypeMask)
{
case cbOldPacketFormatLengthOneByte: _iDataLength = abPaketBytes[iOffset + iPartialDataLength + 1]; _iHeaderLength = 2; break;
case cbOldPacketFormatLengthTwoBytes: _iDataLength = abPaketBytes[iOffset + iPartialDataLength + 1] << 8 | abPaketBytes[iOffset + iPartialDataLength + 2]; _iHeaderLength = 3; break;
case cbOldPacketFormatLengthFourBytes: _iDataLength = abPaketBytes[iOffset + iPartialDataLength + 1] << 24 | abPaketBytes[iOffset + iPartialDataLength + 2] << 16 | abPaketBytes[iOffset + iPartialDataLength + 3] << 8 | abPaketBytes[iOffset + iPartialDataLength + 4]; _iHeaderLength = 5; break;
default: _iDataLength = -1; _eStatus = nStatus.IndeterminateLengthNotSupported; break;
}
}
if (isPartialLength)
{
iPartialDataLength += (1 + _iDataLength);
}
} while (isPartialLength);
if ((_iDataLength < 0) || (_eStatus != nStatus.OK) || (iOffset + iPartialDataLength + _iHeaderLength + _iDataLength > abPaketBytes.Length))
{
if (_eStatus == nStatus.OK)
{
_eStatus = nStatus.ParseError;
}
}
else
{
switch (iPacketType)
{
case 1: _ePacketTag = nPacketTag.PublicKeyEncryptedKey; break;
case 2: _ePacketTag = nPacketTag.Signature; break;
case 5: _ePacketTag = nPacketTag.PrivateKey; break;
case 6: _ePacketTag = nPacketTag.PublicKey; break;
case 7: _ePacketTag = nPacketTag.PrivateSubkey; break;
case 13: _ePacketTag = nPacketTag.UserId; break;
case 14: _ePacketTag = nPacketTag.PublicSubkey; break;
case 18: _ePacketTag = nPacketTag.SymmetricallyEncryptedProtected; break;
default: _eStatus = nStatus.ParseError; break;
}
}
}
}
if (_eStatus == nStatus.OK)
{
if (aiPartialHeaderOffsets == null)
{
_abRawBytes = new byte[_iHeaderLength + _iDataLength];
for (i = 0; i < _iHeaderLength + _iDataLength; i++)
{
_abRawBytes[i] = abPaketBytes[iOffset + i];
}
}
else // TODO correct for handling of _iHeaderLength
{
_iPartialHeaders = aiPartialHeaderOffsets.Length;
_abRawBytes = new byte[iPartialDataLength + _iDataLength - _iPartialHeaders];
j = k = 0;
for (i = 0; i < iPartialDataLength; i++)
{
if ((j < aiPartialHeaderOffsets.Length) && (aiPartialHeaderOffsets[j] == i))
{
j++;
}
else
{
_abRawBytes[k++] = abPaketBytes[iOffset + i + 1];
}
}
for (i = 0; i < _iDataLength; i++)
{
_abRawBytes[k++] = abPaketBytes[iOffset + iPartialDataLength + _iHeaderLength + i];
}
_iDataLength = _abRawBytes.Length;
// for (i = 0; i < _abRawBytes.Length; i++)
// Console.Write(_abRawBytes[i].ToString("x2") + " ");
// Console.WriteLine();
}
}
}
protected PgpPacket(PgpPacket FromPacket) : base(FromPacket)
{
_isNewPacketFormat = FromPacket.isNewPacketFormat;
_ePacketTag = FromPacket.ePacketTag;
_iPartialHeaders = FromPacket.iPartialHeaders;
}
protected PgpPacket(nPacketTag ePacketTag) : base()
{
_isNewPacketFormat = false;
_ePacketTag = ePacketTag;
_iPartialHeaders = 0;
}
protected PgpPublicKey(nPacketTag ePacketTag) : base(ePacketTag)
{
Initialise();
}
