private SignatureSubpacket[] insertSubpacket(SignatureSubpacket[] packets, SignatureSubpacket subpacket)
{
SignatureSubpacket[] array = new SignatureSubpacket[packets.Length + 1];
array[0] = subpacket;
((global::System.Array)packets).CopyTo((global::System.Array)array, 1);
return(array);
}
/**
* Return all signature subpackets of the passed in type.
* @param type subpacket type code
* @return an array of zero or more matching subpackets.
*/
public SignatureSubpacket[] GetSubpackets(
SignatureSubpacketTag type)
{
int count = 0;
for (int i = 0; i < packets.Length; ++i)
{
if (packets[i].SubpacketType == type)
{
++count;
}
}
SignatureSubpacket[] result = new SignatureSubpacket[count];
int pos = 0;
for (int i = 0; i < packets.Length; ++i)
{
if (packets[i].SubpacketType == type)
{
result[pos++] = packets[i];
}
}
return(result);
}
/**
* Return all signature subpackets of the passed in type.
* @param type subpacket type code
* @return an array of zero or more matching subpackets.
*/
public SignatureSubpacket[] GetSubpackets(
SignatureSubpacketTag type)
{
int count = 0;
for (int i = 0; i < packets.Length; ++i)
{
if (packets[i].SubpacketType == type)
{
++count;
}
}
SignatureSubpacket[] result = new SignatureSubpacket[count];
int pos = 0;
for (int i = 0; i < packets.Length; ++i)
{
if (packets[i].SubpacketType == type)
{
result[pos++] = packets[i];
}
}
return result;
}
private SignatureSubpacket[] insertSubpacket(SignatureSubpacket[] packets, SignatureSubpacket subpacket)
{
SignatureSubpacket[] array = new SignatureSubpacket[packets.Length + 1];
array[0] = subpacket;
packets.CopyTo(array, 1);
return(array);
}
/// <summary>
/// Inserts the subpacket.
/// </summary>
/// <param name="packets">The packets.</param>
/// <param name="subpacket">The subpacket.</param>
/// <returns></returns>
private static SignatureSubpacket[] InsertSubpacket(ISignatureSubpacket[] packets, SignatureSubpacket subpacket)
{
var tmp = new SignatureSubpacket[packets.Length + 1];
tmp[0] = subpacket;
packets.CopyTo(tmp, 1);
return(tmp);
}
public PgpSignatureSubpacketVector Generate()
{
SignatureSubpacket[] array = new SignatureSubpacket[list.Count];
for (int i = 0; i < list.Count; i++)
{
array[i] = (SignatureSubpacket)list[i];
}
return(new PgpSignatureSubpacketVector(array));
}
private SignatureSubpacket[] insertSubpacket(
SignatureSubpacket[] packets,
SignatureSubpacket subpacket)
{
SignatureSubpacket[] tmp = new SignatureSubpacket[packets.Length + 1];
tmp[0] = subpacket;
packets.CopyTo(tmp, 1);
return(tmp);
}
public PgpSignatureSubpacketVector Generate()
{
SignatureSubpacket[] a = new SignatureSubpacket[list.Count];
for (int i = 0; i < list.Count; ++i)
{
a[i] = (SignatureSubpacket)list[i];
}
return(new PgpSignatureSubpacketVector(a));
}
public PgpSignatureSubpacketVector Generate()
{
SignatureSubpacket[] array = new SignatureSubpacket[((global::System.Collections.ICollection)list).get_Count()];
for (int i = 0; i < ((global::System.Collections.ICollection)list).get_Count(); i++)
{
array[i] = (SignatureSubpacket)list.get_Item(i);
}
return(new PgpSignatureSubpacketVector(array));
}
public Features GetFeatures()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.Features);
if (subpacket == null)
{
return(null);
}
return(new Features(subpacket.IsCritical(), subpacket.IsLongLength(), subpacket.GetData()));
}
public string GetSignerUserId()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.SignerUserId);
if (subpacket != null)
{
return(((SignerUserId)subpacket).GetId());
}
return(null);
}
public int GetKeyFlags()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.KeyFlags);
if (subpacket != null)
{
return(((KeyFlags)subpacket).Flags);
}
return(0);
}
public int[] GetPreferredCompressionAlgorithms()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.PreferredCompressionAlgorithms);
if (subpacket != null)
{
return(((PreferredAlgorithms)subpacket).GetPreferences());
}
return(null);
}
public long GetKeyExpirationTime()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.KeyExpireTime);
if (subpacket != null)
{
return(((KeyExpirationTime)subpacket).Time);
}
return(0L);
}
public DateTime GetSignatureCreationTime()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.CreationTime);
if (subpacket == null)
{
throw new PgpException("SignatureCreationTime not available");
}
return(((SignatureCreationTime)subpacket).GetTime());
}
public long GetIssuerKeyId()
{
SignatureSubpacket subpacket = GetSubpacket(SignatureSubpacketTag.IssuerKeyId);
if (subpacket != null)
{
return(((IssuerKeyId)subpacket).KeyId);
}
return(0L);
}
public Features GetFeatures()
{
SignatureSubpacket p = this.GetSubpacket(SignatureSubpacketTag.Features);
if (p == null)
{
return(null);
}
return(new Features(p.IsCritical(), p.IsLongLength(), p.GetData()));
}
public SignatureSubpacket[] GetSubpackets(SignatureSubpacketTag type)
{
int num = 0;
for (int i = 0; i < packets.Length; i++)
{
if (packets[i].SubpacketType == type)
{
num++;
}
}
SignatureSubpacket[] array = new SignatureSubpacket[num];
int num2 = 0;
for (int j = 0; j < packets.Length; j++)
{
if (packets[j].SubpacketType == type)
{
array[num2++] = packets[j];
}
}
return(array);
}
public string GetSignerUserId()
{
SignatureSubpacket p = GetSubpacket(SignatureSubpacketTag.SignerUserId);
return(p == null ? null : ((SignerUserId)p).GetId());
}
public int GetKeyFlags()
{
SignatureSubpacket p = GetSubpacket(SignatureSubpacketTag.KeyFlags);
return(p == null ? 0 : ((KeyFlags)p).Flags);
}
public int[] GetPreferredCompressionAlgorithms()
{
SignatureSubpacket p = GetSubpacket(SignatureSubpacketTag.PreferredCompressionAlgorithms);
return(p == null ? null : ((PreferredAlgorithms)p).GetPreferences());
}
/// <summary>
/// Return the number of seconds a key is valid for after its creation date.
/// A value of zero means the key never expires.
/// </summary>
/// <returns>Seconds a signature is valid for.</returns>
public long GetKeyExpirationTime()
{
SignatureSubpacket p = GetSubpacket(SignatureSubpacketTag.KeyExpireTime);
return(p == null ? 0 : ((KeyExpirationTime)p).Time);
}
public int[] GetPreferredSymmetricAlgorithms()
{
SignatureSubpacket p = this.GetSubpacket(SignatureSubpacketTag.PreferredSymmetricAlgorithms);
return(p == null ? null : ((PreferredAlgorithms)p).GetPreferences());
}
/// <summary>
/// Return the number of seconds a signature is valid for after its creation date.
/// A value of zero means the signature never expires.
/// </summary>
/// <returns>Seconds a signature is valid for.</returns>
public long GetSignatureExpirationTime()
{
SignatureSubpacket p = this.GetSubpacket(SignatureSubpacketTag.ExpireTime);
return(p == null ? 0 : ((SignatureExpirationTime)p).Time);
}
public PgpSignatureSubpacketVector Generate()
{
SignatureSubpacket[] a = new SignatureSubpacket[list.Count];
for (int i = 0; i < list.Count; ++i)
{
a[i] = (SignatureSubpacket)list[i];
}
return new PgpSignatureSubpacketVector(a);
}
/// <summary>
/// Inserts the subpacket.
/// </summary>
/// <param name="packets">The packets.</param>
/// <param name="subpacket">The subpacket.</param>
/// <returns></returns>
private static SignatureSubpacket[] InsertSubpacket(ISignatureSubpacket[] packets, SignatureSubpacket subpacket)
{
var tmp = new SignatureSubpacket[packets.Length + 1];
tmp[0] = subpacket;
packets.CopyTo(tmp, 1);
return tmp;
}
private PgpSignatureSubpacketVector createSubpacketVector(SignatureSubpacket[] pcks)
{
return pcks == null ? null : new PgpSignatureSubpacketVector(pcks);
}
internal SignaturePacket(BcpgInputStream bcpgIn)
{
version = bcpgIn.ReadByte();
if (version == 3 || version == 2)
{
bcpgIn.ReadByte();
signatureType = bcpgIn.ReadByte();
creationTime = (((long)bcpgIn.ReadByte() << 24) | ((long)bcpgIn.ReadByte() << 16) | ((long)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte()) * 1000;
keyId |= (long)bcpgIn.ReadByte() << 56;
keyId |= (long)bcpgIn.ReadByte() << 48;
keyId |= (long)bcpgIn.ReadByte() << 40;
keyId |= (long)bcpgIn.ReadByte() << 32;
keyId |= (long)bcpgIn.ReadByte() << 24;
keyId |= (long)bcpgIn.ReadByte() << 16;
keyId |= (long)bcpgIn.ReadByte() << 8;
keyId |= (uint)bcpgIn.ReadByte();
keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte();
hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte();
}
else
{
if (version != 4)
{
throw new Exception("unsupported version: " + version);
}
signatureType = bcpgIn.ReadByte();
keyAlgorithm = (PublicKeyAlgorithmTag)bcpgIn.ReadByte();
hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte();
int num = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte();
byte[] buffer = new byte[num];
bcpgIn.ReadFully(buffer);
SignatureSubpacketsParser signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer, writable: false));
IList list = Platform.CreateArrayList();
SignatureSubpacket value;
while ((value = signatureSubpacketsParser.ReadPacket()) != null)
{
list.Add(value);
}
hashedData = new SignatureSubpacket[list.Count];
for (int i = 0; i != hashedData.Length; i++)
{
SignatureSubpacket signatureSubpacket = (SignatureSubpacket)list[i];
if (signatureSubpacket is IssuerKeyId)
{
keyId = ((IssuerKeyId)signatureSubpacket).KeyId;
}
else if (signatureSubpacket is SignatureCreationTime)
{
creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket).GetTime());
}
hashedData[i] = signatureSubpacket;
}
int num2 = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte();
byte[] buffer2 = new byte[num2];
bcpgIn.ReadFully(buffer2);
signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer2, writable: false));
list.Clear();
while ((value = signatureSubpacketsParser.ReadPacket()) != null)
{
list.Add(value);
}
unhashedData = new SignatureSubpacket[list.Count];
for (int j = 0; j != unhashedData.Length; j++)
{
SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list[j];
if (signatureSubpacket2 is IssuerKeyId)
{
keyId = ((IssuerKeyId)signatureSubpacket2).KeyId;
}
unhashedData[j] = signatureSubpacket2;
}
}
fingerprint = new byte[2];
bcpgIn.ReadFully(fingerprint);
switch (keyAlgorithm)
{
case PublicKeyAlgorithmTag.RsaGeneral:
case PublicKeyAlgorithmTag.RsaSign:
{
MPInteger mPInteger8 = new MPInteger(bcpgIn);
signature = new MPInteger[1]
{
mPInteger8
};
return;
}
case PublicKeyAlgorithmTag.Dsa:
{
MPInteger mPInteger6 = new MPInteger(bcpgIn);
MPInteger mPInteger7 = new MPInteger(bcpgIn);
signature = new MPInteger[2]
{
mPInteger6,
mPInteger7
};
return;
}
case PublicKeyAlgorithmTag.ElGamalEncrypt:
case PublicKeyAlgorithmTag.ElGamalGeneral:
{
MPInteger mPInteger3 = new MPInteger(bcpgIn);
MPInteger mPInteger4 = new MPInteger(bcpgIn);
MPInteger mPInteger5 = new MPInteger(bcpgIn);
signature = new MPInteger[3]
{
mPInteger3,
mPInteger4,
mPInteger5
};
return;
}
case PublicKeyAlgorithmTag.ECDsa:
{
MPInteger mPInteger = new MPInteger(bcpgIn);
MPInteger mPInteger2 = new MPInteger(bcpgIn);
signature = new MPInteger[2]
{
mPInteger,
mPInteger2
};
return;
}
}
if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11)
{
signature = null;
MemoryStream memoryStream = new MemoryStream();
int num3;
while ((num3 = bcpgIn.ReadByte()) >= 0)
{
memoryStream.WriteByte((byte)num3);
}
signatureEncoding = memoryStream.ToArray();
return;
}
throw new IOException("unknown signature key algorithm: " + keyAlgorithm);
}
public long GetIssuerKeyId()
{
SignatureSubpacket p = GetSubpacket(SignatureSubpacketTag.IssuerKeyId);
return(p == null ? 0 : ((IssuerKeyId)p).KeyId);
}
private bool packetPresent(
SignatureSubpacket[] packets,
SignatureSubpacketTag type)
{
for (int i = 0; i != packets.Length; i++)
{
if (packets[i].SubpacketType == type)
{
return true;
}
}
return false;
}
private SignatureSubpacket[] insertSubpacket(
SignatureSubpacket[] packets,
SignatureSubpacket subpacket)
{
SignatureSubpacket[] tmp = new SignatureSubpacket[packets.Length + 1];
tmp[0] = subpacket;
packets.CopyTo(tmp, 1);
return tmp;
}
internal PgpSignatureSubpacketVector(
SignatureSubpacket[] packets)
{
this.packets = packets;
}
