Basic type for a PGP Signature sub-packet.
Ejemplo n.º 1
0
        private static byte[] GetEncodedSubpackets(SignatureSubpacket[] ps)
        {
            MemoryStream memoryStream = new MemoryStream();

            for (int i = 0; i < ps.Length; i++)
            {
                SignatureSubpacket signatureSubpacket = ps[i];
                signatureSubpacket.Encode(memoryStream);
            }
            return(memoryStream.ToArray());
        }
Ejemplo n.º 2
0
 /**
 * Generate a version 4 signature packet.
 *
 * @param signatureType
 * @param keyAlgorithm
 * @param hashAlgorithm
 * @param hashedData
 * @param unhashedData
 * @param fingerprint
 * @param signature
 */
 public SignaturePacket(
     int						signatureType,
     long					keyId,
     PublicKeyAlgorithmTag	keyAlgorithm,
     HashAlgorithmTag		hashAlgorithm,
     SignatureSubpacket[]	hashedData,
     SignatureSubpacket[]	unhashedData,
     byte[]					fingerprint,
     MPInteger[]				signature)
     : this(4, signatureType, keyId, keyAlgorithm, hashAlgorithm, hashedData, unhashedData, fingerprint, signature)
 {
 }
Ejemplo n.º 3
0
 private void setCreationTime()
 {
     SignatureSubpacket[] array = this.hashedData;
     for (int i = 0; i < array.Length; i++)
     {
         SignatureSubpacket signatureSubpacket = array[i];
         if (signatureSubpacket is SignatureCreationTime)
         {
             this.creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket).GetTime());
             return;
         }
     }
 }
Ejemplo n.º 4
0
        public override bool Equals(object obj)
        {
            if (obj == this)
            {
                return(true);
            }

            SignatureSubpacket other = obj as SignatureSubpacket;

            if (null == other)
            {
                return(false);
            }

            return(this.type == other.type &&
                   this.critical == other.critical &&
                   Arrays.AreEqual(this.data, other.data));
        }
Ejemplo n.º 5
0
 public SignaturePacket(
     int						version,
     int						signatureType,
     long					keyId,
     PublicKeyAlgorithmTag	keyAlgorithm,
     HashAlgorithmTag		hashAlgorithm,
     SignatureSubpacket[]	hashedData,
     SignatureSubpacket[]	unhashedData,
     byte[]					fingerprint,
     MPInteger[]				signature)
 {
     this.version = version;
     this.signatureType = signatureType;
     this.keyId = keyId;
     this.keyAlgorithm = keyAlgorithm;
     this.hashAlgorithm = hashAlgorithm;
     this.hashedData = hashedData;
     this.unhashedData = unhashedData;
     this.fingerprint = fingerprint;
     this.signature = signature;
 }
Ejemplo n.º 6
0
        internal SignaturePacket(
            BcpgInputStream bcpgIn)
        {
            version = bcpgIn.ReadByte();

            if (version == 3 || version == 2)
            {
//                int l =
                bcpgIn.ReadByte();

                signatureType = bcpgIn.ReadByte();
                creationTime  = (((long)bcpgIn.ReadByte() << 24) | ((long)bcpgIn.ReadByte() << 16)
                                 | ((long)bcpgIn.ReadByte() << 8) | (uint)bcpgIn.ReadByte()) * 1000L;

                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)
            {
                signatureType = bcpgIn.ReadByte();
                keyAlgorithm  = (PublicKeyAlgorithmTag)bcpgIn.ReadByte();
                hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte();

                int    hashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte();
                byte[] hashed       = new byte[hashedLength];

                bcpgIn.ReadFully(hashed);

                //
                // read the signature sub packet data.
                //
                SignatureSubpacketsParser sIn = new SignatureSubpacketsParser(
                    new MemoryStream(hashed, false));

                ArrayList          v = new ArrayList();
                SignatureSubpacket sub;
                while ((sub = sIn.ReadPacket()) != null)
                {
                    v.Add(sub);
                }

                hashedData = new SignatureSubpacket[v.Count];

                for (int i = 0; i != hashedData.Length; i++)
                {
                    SignatureSubpacket p = (SignatureSubpacket)v[i];
                    if (p is IssuerKeyId)
                    {
                        keyId = ((IssuerKeyId)p).KeyId;
                    }
                    else if (p is SignatureCreationTime)
                    {
                        creationTime = DateTimeUtilities.DateTimeToUnixMs(
                            ((SignatureCreationTime)p).GetTime());
                    }

                    hashedData[i] = p;
                }

                int    unhashedLength = (bcpgIn.ReadByte() << 8) | bcpgIn.ReadByte();
                byte[] unhashed       = new byte[unhashedLength];

                bcpgIn.ReadFully(unhashed);

                sIn = new SignatureSubpacketsParser(new MemoryStream(unhashed, false));

                v.Clear();

                while ((sub = sIn.ReadPacket()) != null)
                {
                    v.Add(sub);
                }

                unhashedData = new SignatureSubpacket[v.Count];

                for (int i = 0; i != unhashedData.Length; i++)
                {
                    SignatureSubpacket p = (SignatureSubpacket)v[i];
                    if (p is IssuerKeyId)
                    {
                        keyId = ((IssuerKeyId)p).KeyId;
                    }
                    else if (p is SignatureCreationTime)
                    {
                        creationTime = DateTimeUtilities.DateTimeToUnixMs(
                            ((SignatureCreationTime)p).GetTime());
                    }

                    unhashedData[i] = (SignatureSubpacket)p;
                }
            }
            else
            {
                throw new Exception("unsupported version: " + version);
            }

            fingerprint = new byte[2];
            bcpgIn.ReadFully(fingerprint);

            switch (keyAlgorithm)
            {
            case PublicKeyAlgorithmTag.RsaGeneral:
            case PublicKeyAlgorithmTag.RsaSign:
                MPInteger v = new MPInteger(bcpgIn);
                signature = new MPInteger[] { v };
                break;

            case PublicKeyAlgorithmTag.Dsa:
                MPInteger r = new MPInteger(bcpgIn);
                MPInteger s = new MPInteger(bcpgIn);
                signature = new MPInteger[] { r, s };
                break;

            case PublicKeyAlgorithmTag.ElGamalEncrypt:     // yep, this really does happen sometimes.
            case PublicKeyAlgorithmTag.ElGamalGeneral:
                MPInteger p = new MPInteger(bcpgIn);
                MPInteger g = new MPInteger(bcpgIn);
                MPInteger y = new MPInteger(bcpgIn);
                signature = new MPInteger[] { p, g, y };
                break;

            default:
                throw new IOException("unknown signature key algorithm: " + keyAlgorithm);
            }
        }
Ejemplo n.º 7
0
        internal SignaturePacket(BcpgInputStream bcpgIn)
        {
            //IL_018f: Unknown result type (might be due to invalid IL or missing references)
            //IL_0199: Expected O, but got Unknown
            //IL_025a: Unknown result type (might be due to invalid IL or missing references)
            //IL_0264: Expected O, but got Unknown
            //IL_0422: Unknown result type (might be due to invalid IL or missing references)
            //IL_0429: Expected O, but got Unknown
            //IL_0464: Unknown result type (might be due to invalid IL or missing references)
            version = ((Stream)bcpgIn).ReadByte();
            if (version == 3 || version == 2)
            {
                ((Stream)bcpgIn).ReadByte();
                signatureType = ((Stream)bcpgIn).ReadByte();
                creationTime  = (((long)((Stream)bcpgIn).ReadByte() << 24) | ((long)((Stream)bcpgIn).ReadByte() << 16) | ((long)((Stream)bcpgIn).ReadByte() << 8) | (uint)((Stream)bcpgIn).ReadByte()) * 1000;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 56;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 48;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 40;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 32;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 24;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 16;
                keyId        |= (long)((Stream)bcpgIn).ReadByte() << 8;
                keyId        |= (uint)((Stream)bcpgIn).ReadByte();
                keyAlgorithm  = (PublicKeyAlgorithmTag)((Stream)bcpgIn).ReadByte();
                hashAlgorithm = (HashAlgorithmTag)((Stream)bcpgIn).ReadByte();
            }
            else
            {
                if (version != 4)
                {
                    throw new global::System.Exception(string.Concat((object)"unsupported version: ", (object)version));
                }
                signatureType = ((Stream)bcpgIn).ReadByte();
                keyAlgorithm  = (PublicKeyAlgorithmTag)((Stream)bcpgIn).ReadByte();
                hashAlgorithm = (HashAlgorithmTag)((Stream)bcpgIn).ReadByte();
                int    num   = (((Stream)bcpgIn).ReadByte() << 8) | ((Stream)bcpgIn).ReadByte();
                byte[] array = new byte[num];
                bcpgIn.ReadFully(array);
                SignatureSubpacketsParser        signatureSubpacketsParser = new SignatureSubpacketsParser((Stream) new MemoryStream(array, false));
                global::System.Collections.IList list = Platform.CreateArrayList();
                SignatureSubpacket signatureSubpacket;
                while ((signatureSubpacket = signatureSubpacketsParser.ReadPacket()) != null)
                {
                    list.Add((object)signatureSubpacket);
                }
                hashedData = new SignatureSubpacket[((global::System.Collections.ICollection)list).get_Count()];
                for (int i = 0; i != hashedData.Length; i++)
                {
                    SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list.get_Item(i);
                    if (signatureSubpacket2 is IssuerKeyId)
                    {
                        keyId = ((IssuerKeyId)signatureSubpacket2).KeyId;
                    }
                    else if (signatureSubpacket2 is SignatureCreationTime)
                    {
                        creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket2).GetTime());
                    }
                    hashedData[i] = signatureSubpacket2;
                }
                int    num2   = (((Stream)bcpgIn).ReadByte() << 8) | ((Stream)bcpgIn).ReadByte();
                byte[] array2 = new byte[num2];
                bcpgIn.ReadFully(array2);
                signatureSubpacketsParser = new SignatureSubpacketsParser((Stream) new MemoryStream(array2, false));
                list.Clear();
                while ((signatureSubpacket = signatureSubpacketsParser.ReadPacket()) != null)
                {
                    list.Add((object)signatureSubpacket);
                }
                unhashedData = new SignatureSubpacket[((global::System.Collections.ICollection)list).get_Count()];
                for (int j = 0; j != unhashedData.Length; j++)
                {
                    SignatureSubpacket signatureSubpacket3 = (SignatureSubpacket)list.get_Item(j);
                    if (signatureSubpacket3 is IssuerKeyId)
                    {
                        keyId = ((IssuerKeyId)signatureSubpacket3).KeyId;
                    }
                    unhashedData[j] = signatureSubpacket3;
                }
            }
            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 val = new MemoryStream();
                int          num3;
                while ((num3 = ((Stream)bcpgIn).ReadByte()) >= 0)
                {
                    ((Stream)val).WriteByte((byte)num3);
                }
                signatureEncoding = val.ToArray();
                return;
            }
            throw new IOException(string.Concat((object)"unknown signature key algorithm: ", (object)keyAlgorithm));
        }
Ejemplo n.º 8
0
		private static byte[] GetEncodedSubpackets(
			SignatureSubpacket[] ps)
		{
			MemoryStream sOut = new MemoryStream();

			foreach (SignatureSubpacket p in ps)
			{
				p.Encode(sOut);
			}

			return sOut.ToArray();
		}
Ejemplo n.º 9
0
        internal SignaturePacket(BcpgInputStream bcpgIn)
        {
            this.version = bcpgIn.ReadByte();
            if (this.version == 3 || this.version == 2)
            {
                bcpgIn.ReadByte();
                this.signatureType = bcpgIn.ReadByte();
                this.creationTime  = ((long)bcpgIn.ReadByte() << 24 | (long)bcpgIn.ReadByte() << 16 | (long)bcpgIn.ReadByte() << 8 | (long)((ulong)bcpgIn.ReadByte())) * 1000L;
                this.keyId        |= (long)bcpgIn.ReadByte() << 56;
                this.keyId        |= (long)bcpgIn.ReadByte() << 48;
                this.keyId        |= (long)bcpgIn.ReadByte() << 40;
                this.keyId        |= (long)bcpgIn.ReadByte() << 32;
                this.keyId        |= (long)bcpgIn.ReadByte() << 24;
                this.keyId        |= (long)bcpgIn.ReadByte() << 16;
                this.keyId        |= (long)bcpgIn.ReadByte() << 8;
                this.keyId        |= (long)((ulong)bcpgIn.ReadByte());
                this.keyAlgorithm  = (PublicKeyAlgorithmTag)bcpgIn.ReadByte();
                this.hashAlgorithm = (HashAlgorithmTag)bcpgIn.ReadByte();
            }
            else
            {
                if (this.version != 4)
                {
                    throw new Exception("unsupported version: " + this.version);
                }
                this.signatureType = bcpgIn.ReadByte();
                this.keyAlgorithm  = (PublicKeyAlgorithmTag)bcpgIn.ReadByte();
                this.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, false));
                IList list = Platform.CreateArrayList();
                SignatureSubpacket value;
                while ((value = signatureSubpacketsParser.ReadPacket()) != null)
                {
                    list.Add(value);
                }
                this.hashedData = new SignatureSubpacket[list.Count];
                for (int num2 = 0; num2 != this.hashedData.Length; num2++)
                {
                    SignatureSubpacket signatureSubpacket = (SignatureSubpacket)list[num2];
                    if (signatureSubpacket is IssuerKeyId)
                    {
                        this.keyId = ((IssuerKeyId)signatureSubpacket).KeyId;
                    }
                    else if (signatureSubpacket is SignatureCreationTime)
                    {
                        this.creationTime = DateTimeUtilities.DateTimeToUnixMs(((SignatureCreationTime)signatureSubpacket).GetTime());
                    }
                    this.hashedData[num2] = signatureSubpacket;
                }
                int    num3    = bcpgIn.ReadByte() << 8 | bcpgIn.ReadByte();
                byte[] buffer2 = new byte[num3];
                bcpgIn.ReadFully(buffer2);
                signatureSubpacketsParser = new SignatureSubpacketsParser(new MemoryStream(buffer2, false));
                list.Clear();
                while ((value = signatureSubpacketsParser.ReadPacket()) != null)
                {
                    list.Add(value);
                }
                this.unhashedData = new SignatureSubpacket[list.Count];
                for (int num4 = 0; num4 != this.unhashedData.Length; num4++)
                {
                    SignatureSubpacket signatureSubpacket2 = (SignatureSubpacket)list[num4];
                    if (signatureSubpacket2 is IssuerKeyId)
                    {
                        this.keyId = ((IssuerKeyId)signatureSubpacket2).KeyId;
                    }
                    this.unhashedData[num4] = signatureSubpacket2;
                }
            }
            this.fingerprint = new byte[2];
            bcpgIn.ReadFully(this.fingerprint);
            PublicKeyAlgorithmTag publicKeyAlgorithmTag = this.keyAlgorithm;

            switch (publicKeyAlgorithmTag)
            {
            case PublicKeyAlgorithmTag.RsaGeneral:
            case PublicKeyAlgorithmTag.RsaSign:
            {
                MPInteger mPInteger = new MPInteger(bcpgIn);
                this.signature = new MPInteger[]
                {
                    mPInteger
                };
                return;
            }

            case PublicKeyAlgorithmTag.RsaEncrypt:
                break;

            default:
                switch (publicKeyAlgorithmTag)
                {
                case PublicKeyAlgorithmTag.ElGamalEncrypt:
                case PublicKeyAlgorithmTag.ElGamalGeneral:
                {
                    MPInteger mPInteger2 = new MPInteger(bcpgIn);
                    MPInteger mPInteger3 = new MPInteger(bcpgIn);
                    MPInteger mPInteger4 = new MPInteger(bcpgIn);
                    this.signature = new MPInteger[]
                    {
                        mPInteger2,
                        mPInteger3,
                        mPInteger4
                    };
                    return;
                }

                case PublicKeyAlgorithmTag.Dsa:
                {
                    MPInteger mPInteger5 = new MPInteger(bcpgIn);
                    MPInteger mPInteger6 = new MPInteger(bcpgIn);
                    this.signature = new MPInteger[]
                    {
                        mPInteger5,
                        mPInteger6
                    };
                    return;
                }
                }
                break;
            }
            if (this.keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && this.keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11)
            {
                this.signature = null;
                MemoryStream memoryStream = new MemoryStream();
                int          num5;
                while ((num5 = bcpgIn.ReadByte()) >= 0)
                {
                    memoryStream.WriteByte((byte)num5);
                }
                this.signatureEncoding = memoryStream.ToArray();
                return;
            }
            throw new IOException("unknown signature key algorithm: " + this.keyAlgorithm);
        }