/**
  * @param in
  */
 public ElGamalSecretBcpgKey(
     BcpgInputStream bcpgIn)
 {
     this.x = new MPInteger(bcpgIn);
 }
Exemple #2
0
 public UserIdPacket(
     BcpgInputStream bcpgIn)
 {
     this.idData = bcpgIn.ReadAll();
 }
Exemple #3
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));

                IList v = Platform.CreateArrayList();
                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;
                    }

                    unhashedData[i] = 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;

            case PublicKeyAlgorithmTag.ECDsa:
                MPInteger ecR = new MPInteger(bcpgIn);
                MPInteger ecS = new MPInteger(bcpgIn);
                signature = new MPInteger[] { ecR, ecS };
                break;

            default:
                if (keyAlgorithm >= PublicKeyAlgorithmTag.Experimental_1 && keyAlgorithm <= PublicKeyAlgorithmTag.Experimental_11)
                {
                    signature = null;
                    MemoryStream bOut = new MemoryStream();
                    int          ch;
                    while ((ch = bcpgIn.ReadByte()) >= 0)
                    {
                        bOut.WriteByte((byte)ch);
                    }
                    signatureEncoding = bOut.ToArray();
                }
                else
                {
                    throw new IOException("unknown signature key algorithm: " + keyAlgorithm);
                }
                break;
            }
        }
        public Packet ReadPacket()
        {
            int hdr = this.ReadByte();

            if (hdr < 0)
            {
                return(null);
            }

            if ((hdr & 0x80) == 0)
            {
                throw new IOException("invalid header encountered");
            }

            bool      newPacket = (hdr & 0x40) != 0;
            PacketTag tag       = 0;
            int       bodyLen   = 0;
            bool      partial   = false;

            if (newPacket)
            {
                tag = (PacketTag)(hdr & 0x3f);

                int l = this.ReadByte();

                if (l < 192)
                {
                    bodyLen = l;
                }
                else if (l <= 223)
                {
                    int b = m_in.ReadByte();
                    bodyLen = ((l - 192) << 8) + (b) + 192;
                }
                else if (l == 255)
                {
                    bodyLen = (m_in.ReadByte() << 24) | (m_in.ReadByte() << 16)
                              | (m_in.ReadByte() << 8) | m_in.ReadByte();
                }
                else
                {
                    partial = true;
                    bodyLen = 1 << (l & 0x1f);
                }
            }
            else
            {
                int lengthType = hdr & 0x3;

                tag = (PacketTag)((hdr & 0x3f) >> 2);

                switch (lengthType)
                {
                case 0:
                    bodyLen = this.ReadByte();
                    break;

                case 1:
                    bodyLen = (this.ReadByte() << 8) | this.ReadByte();
                    break;

                case 2:
                    bodyLen = (this.ReadByte() << 24) | (this.ReadByte() << 16)
                              | (this.ReadByte() << 8) | this.ReadByte();
                    break;

                case 3:
                    partial = true;
                    break;

                default:
                    throw new IOException("unknown length type encountered");
                }
            }

            BcpgInputStream objStream;

            if (bodyLen == 0 && partial)
            {
                objStream = this;
            }
            else
            {
                PartialInputStream pis = new PartialInputStream(this, partial, bodyLen);
                objStream = new BcpgInputStream(pis);
            }

            switch (tag)
            {
            case PacketTag.Reserved:
                return(new InputStreamPacket(objStream));

            case PacketTag.PublicKeyEncryptedSession:
                return(new PublicKeyEncSessionPacket(objStream));

            case PacketTag.Signature:
                return(new SignaturePacket(objStream));

            case PacketTag.SymmetricKeyEncryptedSessionKey:
                return(new SymmetricKeyEncSessionPacket(objStream));

            case PacketTag.OnePassSignature:
                return(new OnePassSignaturePacket(objStream));

            case PacketTag.SecretKey:
                return(new SecretKeyPacket(objStream));

            case PacketTag.PublicKey:
                return(new PublicKeyPacket(objStream));

            case PacketTag.SecretSubkey:
                return(new SecretSubkeyPacket(objStream));

            case PacketTag.CompressedData:
                return(new CompressedDataPacket(objStream));

            case PacketTag.SymmetricKeyEncrypted:
                return(new SymmetricEncDataPacket(objStream));

            case PacketTag.Marker:
                return(new MarkerPacket(objStream));

            case PacketTag.LiteralData:
                return(new LiteralDataPacket(objStream));

            case PacketTag.Trust:
                return(new TrustPacket(objStream));

            case PacketTag.UserId:
                return(new UserIdPacket(objStream));

            case PacketTag.UserAttribute:
                return(new UserAttributePacket(objStream));

            case PacketTag.PublicSubkey:
                return(new PublicSubkeyPacket(objStream));

            case PacketTag.SymmetricEncryptedIntegrityProtected:
                return(new SymmetricEncIntegrityPacket(objStream));

            case PacketTag.ModificationDetectionCode:
                return(new ModDetectionCodePacket(objStream));

            case PacketTag.Experimental1:
            case PacketTag.Experimental2:
            case PacketTag.Experimental3:
            case PacketTag.Experimental4:
                return(new ExperimentalPacket(tag, objStream));

            default:
                throw new IOException("unknown packet type encountered: " + tag);
            }
        }
 /// <summary>Construct an RSA public key from the passed in stream.</summary>
 public RsaPublicBcpgKey(
     BcpgInputStream bcpgIn)
 {
     this.n = new MPInteger(bcpgIn);
     this.e = new MPInteger(bcpgIn);
 }