public PgpEncryptedDataList(
            BcpgInputStream bcpgInput)
        {
            var packets = new List <Packet>();

            while (bcpgInput.NextPacketTag() == PacketTag.PublicKeyEncryptedSession ||
                   bcpgInput.NextPacketTag() == PacketTag.SymmetricKeyEncryptedSessionKey)
            {
                packets.Add(bcpgInput.ReadPacket());
            }

            _list = Platform.CreateArrayList <PgpEncryptedData>(packets.Count);
            _data = (InputStreamPacket)bcpgInput.ReadPacket();
            for (var i = 0; i != packets.Count; i++)
            {
                var symmetricPacket = packets[i] as SymmetricKeyEncSessionPacket;
                if (symmetricPacket != null)
                {
                    _list.Add(new PgpPbeEncryptedData(symmetricPacket, _data));
                }
                else
                {
                    _list.Add(new PgpPublicKeyEncryptedData((PublicKeyEncSessionPacket)packets[i], _data));
                }
            }
        }
示例#2
0
        public PgpEncryptedDataList(
            BcpgInputStream bcpgInput)
        {
            while (bcpgInput.NextPacketTag() == PacketTag.PublicKeyEncryptedSession ||
                   bcpgInput.NextPacketTag() == PacketTag.SymmetricKeyEncryptedSessionKey)
            {
                list.Add(bcpgInput.ReadPacket());
            }

            Packet packet = bcpgInput.ReadPacket();

            if (!(packet is InputStreamPacket))
            {
                throw new IOException("unexpected packet in stream: " + packet);
            }

            this.data = (InputStreamPacket)packet;

            for (int i = 0; i != list.Count; i++)
            {
                if (list[i] is SymmetricKeyEncSessionPacket)
                {
                    list[i] = new PgpPbeEncryptedData((SymmetricKeyEncSessionPacket)list[i], data);
                }
                else
                {
                    list[i] = new PgpPublicKeyEncryptedData((PublicKeyEncSessionPacket)list[i], data);
                }
            }
        }
 internal static TrustPacket ReadOptionalTrustPacket(
     BcpgInputStream bcpgInput)
 {
     return((bcpgInput.NextPacketTag() == PacketTag.Trust)
                         ?       (TrustPacket)bcpgInput.ReadPacket()
                         :       null);
 }
        internal static void ReadUserIDs(
            BcpgInputStream bcpgInput,
            out ArrayList ids,
            out ArrayList idTrusts,
            out ArrayList idSigs)
        {
            ids      = new ArrayList();
            idTrusts = new ArrayList();
            idSigs   = new ArrayList();

            while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
                   bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
            {
                Packet obj = bcpgInput.ReadPacket();
                if (obj is UserIdPacket)
                {
                    UserIdPacket id = (UserIdPacket)obj;
                    ids.Add(id.GetId());
                }
                else
                {
                    UserAttributePacket user = (UserAttributePacket)obj;
                    ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                }

                idTrusts.Add(
                    ReadOptionalTrustPacket(bcpgInput));

                idSigs.Add(
                    ReadSignaturesAndTrust(bcpgInput));
            }
        }
示例#5
0
        internal static void ReadUserIDs(BcpgInputStream bcpgInput, out IList ids, out IList <ITrustPacket> idTrusts, out IList <IList <IPgpSignature> > idSigs)
        {
            ids      = Platform.CreateArrayList();
            idTrusts = Platform.CreateArrayList <ITrustPacket>();
            idSigs   = Platform.CreateArrayList <IList <IPgpSignature> >();

            while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
                   bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
            {
                var obj          = bcpgInput.ReadPacket();
                var userIdPacket = obj as UserIdPacket;
                if (userIdPacket != null)
                {
                    ids.Add(userIdPacket.GetId());
                }
                else
                {
                    var user = (UserAttributePacket)obj;
                    ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                }

                idTrusts.Add(ReadOptionalTrustPacket(bcpgInput));

                idSigs.Add(ReadSignaturesAndTrust(bcpgInput));
            }
        }
示例#6
0
        public PgpPublicKeyRing(
            Stream inputStream)
        {
            this.keys = Platform.CreateArrayList();

            BcpgInputStream bcpgInput = BcpgInputStream.Wrap(inputStream);

            PacketTag initialTag = bcpgInput.NextPacketTag();

            if (initialTag != PacketTag.PublicKey && initialTag != PacketTag.PublicSubkey)
            {
                throw new IOException("public key ring doesn't start with public key tag: "
                                      + "tag 0x" + ((int)initialTag).ToString("X"));
            }

            PublicKeyPacket pubPk   = (PublicKeyPacket)bcpgInput.ReadPacket();;
            TrustPacket     trustPk = ReadOptionalTrustPacket(bcpgInput);

            // direct signatures and revocations
            IList keySigs = ReadSignaturesAndTrust(bcpgInput);

            IList ids, idTrusts, idSigs;

            ReadUserIDs(bcpgInput, out ids, out idTrusts, out idSigs);

            keys.Add(new PgpPublicKey(pubPk, trustPk, keySigs, ids, idTrusts, idSigs));


            // Read subkeys
            while (bcpgInput.NextPacketTag() == PacketTag.PublicSubkey)
            {
                keys.Add(ReadSubkey(bcpgInput));
            }
        }
示例#7
0
		internal static void ReadUserIDs(
			BcpgInputStream	bcpgInput,
			out IList       ids,
			out IList       idTrusts,
			out IList       idSigs)
		{
			ids = Platform.CreateArrayList();
            idTrusts = Platform.CreateArrayList();
            idSigs = Platform.CreateArrayList();

			while (bcpgInput.NextPacketTag() == PacketTag.UserId
				|| bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
			{
				Packet obj = bcpgInput.ReadPacket();
				if (obj is UserIdPacket)
				{
					UserIdPacket id = (UserIdPacket)obj;
					ids.Add(id.GetId());
				}
				else
				{
					UserAttributePacket user = (UserAttributePacket) obj;
					ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
				}

				idTrusts.Add(
					ReadOptionalTrustPacket(bcpgInput));

				idSigs.Add(
					ReadSignaturesAndTrust(bcpgInput));
			}
		}
        internal static void ReadUserIDs(BcpgInputStream bcpgInput, out IList ids, out IList<ITrustPacket> idTrusts, out IList<IList<IPgpSignature>> idSigs)
        {
            ids = Platform.CreateArrayList();
            idTrusts = Platform.CreateArrayList<ITrustPacket>();
            idSigs = Platform.CreateArrayList<IList<IPgpSignature>>();

            while (bcpgInput.NextPacketTag() == PacketTag.UserId
                || bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
            {
                var obj = bcpgInput.ReadPacket();
                var userIdPacket = obj as UserIdPacket;
                if (userIdPacket != null)
                {
                    ids.Add(userIdPacket.GetId());
                }
                else
                {
                    var user = (UserAttributePacket)obj;
                    ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                }

                idTrusts.Add(ReadOptionalTrustPacket(bcpgInput));

                idSigs.Add(ReadSignaturesAndTrust(bcpgInput));
            }
        }
示例#9
0
		internal static TrustPacket ReadOptionalTrustPacket(
			BcpgInputStream bcpgInput)
		{
			return (bcpgInput.NextPacketTag() == PacketTag.Trust)
				?	(TrustPacket) bcpgInput.ReadPacket()
				:	null;
		}
示例#10
0
        }        //IL_0002: Unknown result type (might be due to invalid IL or missing references)

        //IL_000c: Expected O, but got Unknown


        public PgpSecretKeyRing(Stream inputStream)
        {
            //IL_004b: Unknown result type (might be due to invalid IL or missing references)
            keys         = Platform.CreateArrayList();
            extraPubKeys = Platform.CreateArrayList();
            BcpgInputStream bcpgInputStream = BcpgInputStream.Wrap(inputStream);
            PacketTag       packetTag       = bcpgInputStream.NextPacketTag();

            if (packetTag != PacketTag.SecretKey && packetTag != PacketTag.SecretSubkey)
            {
                int num = (int)packetTag;
                throw new IOException("secret key ring doesn't start with secret key tag: tag 0x" + num.ToString("X"));
            }
            SecretKeyPacket secretKeyPacket = (SecretKeyPacket)bcpgInputStream.ReadPacket();

            while (bcpgInputStream.NextPacketTag() == PacketTag.Experimental2)
            {
                bcpgInputStream.ReadPacket();
            }
            TrustPacket trustPk = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);

            global::System.Collections.IList keySigs = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
            PgpKeyRing.ReadUserIDs(bcpgInputStream, out var ids, out var idTrusts, out var idSigs);
            keys.Add((object)new PgpSecretKey(secretKeyPacket, new PgpPublicKey(secretKeyPacket.PublicKeyPacket, trustPk, keySigs, ids, idTrusts, idSigs)));
            while (bcpgInputStream.NextPacketTag() == PacketTag.SecretSubkey || bcpgInputStream.NextPacketTag() == PacketTag.PublicSubkey)
            {
                if (bcpgInputStream.NextPacketTag() == PacketTag.SecretSubkey)
                {
                    SecretSubkeyPacket secretSubkeyPacket = (SecretSubkeyPacket)bcpgInputStream.ReadPacket();
                    while (bcpgInputStream.NextPacketTag() == PacketTag.Experimental2)
                    {
                        bcpgInputStream.ReadPacket();
                    }
                    TrustPacket trustPk2 = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
                    global::System.Collections.IList sigs = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
                    keys.Add((object)new PgpSecretKey(secretSubkeyPacket, new PgpPublicKey(secretSubkeyPacket.PublicKeyPacket, trustPk2, sigs)));
                }
                else
                {
                    PublicSubkeyPacket publicPk            = (PublicSubkeyPacket)bcpgInputStream.ReadPacket();
                    TrustPacket        trustPk3            = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
                    global::System.Collections.IList sigs2 = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
                    extraPubKeys.Add((object)new PgpPublicKey(publicPk, trustPk3, sigs2));
                }
            }
        }
    internal static PgpPublicKey ReadSubkey(BcpgInputStream bcpgInput)
    {
        PublicKeyPacket publicPk = (PublicKeyPacket)bcpgInput.ReadPacket();
        TrustPacket     trustPk  = PgpKeyRing.ReadOptionalTrustPacket(bcpgInput);
        IList           sigs     = PgpKeyRing.ReadSignaturesAndTrust(bcpgInput);

        return(new PgpPublicKey(publicPk, trustPk, sigs));
    }
    public PgpSecretKeyRing(Stream inputStream)
    {
        keys         = Platform.CreateArrayList();
        extraPubKeys = Platform.CreateArrayList();
        BcpgInputStream bcpgInputStream = BcpgInputStream.Wrap(inputStream);
        PacketTag       packetTag       = bcpgInputStream.NextPacketTag();

        if (packetTag != PacketTag.SecretKey && packetTag != PacketTag.SecretSubkey)
        {
            int num = (int)packetTag;
            throw new IOException("secret key ring doesn't start with secret key tag: tag 0x" + num.ToString("X"));
        }
        SecretKeyPacket secretKeyPacket = (SecretKeyPacket)bcpgInputStream.ReadPacket();

        while (bcpgInputStream.NextPacketTag() == PacketTag.Experimental2)
        {
            bcpgInputStream.ReadPacket();
        }
        TrustPacket trustPk = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
        IList       keySigs = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);

        PgpKeyRing.ReadUserIDs(bcpgInputStream, out IList ids, out IList idTrusts, out IList idSigs);
        keys.Add(new PgpSecretKey(secretKeyPacket, new PgpPublicKey(secretKeyPacket.PublicKeyPacket, trustPk, keySigs, ids, idTrusts, idSigs)));
        while (bcpgInputStream.NextPacketTag() == PacketTag.SecretSubkey || bcpgInputStream.NextPacketTag() == PacketTag.PublicSubkey)
        {
            if (bcpgInputStream.NextPacketTag() == PacketTag.SecretSubkey)
            {
                SecretSubkeyPacket secretSubkeyPacket = (SecretSubkeyPacket)bcpgInputStream.ReadPacket();
                while (bcpgInputStream.NextPacketTag() == PacketTag.Experimental2)
                {
                    bcpgInputStream.ReadPacket();
                }
                TrustPacket trustPk2 = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
                IList       sigs     = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
                keys.Add(new PgpSecretKey(secretSubkeyPacket, new PgpPublicKey(secretSubkeyPacket.PublicKeyPacket, trustPk2, sigs)));
            }
            else
            {
                PublicSubkeyPacket publicPk = (PublicSubkeyPacket)bcpgInputStream.ReadPacket();
                TrustPacket        trustPk3 = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
                IList sigs2 = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
                extraPubKeys.Add(new PgpPublicKey(publicPk, trustPk3, sigs2));
            }
        }
    }
 public PgpEncryptedDataList(BcpgInputStream bcpgInput)
 {
     while (bcpgInput.NextPacketTag() == PacketTag.PublicKeyEncryptedSession || bcpgInput.NextPacketTag() == PacketTag.SymmetricKeyEncryptedSessionKey)
     {
         list.Add(bcpgInput.ReadPacket());
     }
     data = (InputStreamPacket)bcpgInput.ReadPacket();
     for (int i = 0; i != list.Count; i++)
     {
         if (list[i] is SymmetricKeyEncSessionPacket)
         {
             list[i] = new PgpPbeEncryptedData((SymmetricKeyEncSessionPacket)list[i], data);
         }
         else
         {
             list[i] = new PgpPublicKeyEncryptedData((PublicKeyEncSessionPacket)list[i], data);
         }
     }
 }
示例#14
0
        internal static PgpPublicKey ReadSubkey(BcpgInputStream bcpgInput)
        {
            PublicKeyPacket pk     = (PublicKeyPacket)bcpgInput.ReadPacket();
            TrustPacket     kTrust = ReadOptionalTrustPacket(bcpgInput);

            // PGP 8 actually leaves out the signature.
            IList sigList = ReadSignaturesAndTrust(bcpgInput);

            return(new PgpPublicKey(pk, kTrust, sigList));
        }
 public PgpEncryptedDataList(BcpgInputStream bcpgInput)
 {
     while (bcpgInput.NextPacketTag() == PacketTag.PublicKeyEncryptedSession || bcpgInput.NextPacketTag() == PacketTag.SymmetricKeyEncryptedSessionKey)
     {
         list.Add((object)bcpgInput.ReadPacket());
     }
     data = (InputStreamPacket)bcpgInput.ReadPacket();
     for (int i = 0; i != ((global::System.Collections.ICollection)list).get_Count(); i++)
     {
         if (list.get_Item(i) is SymmetricKeyEncSessionPacket)
         {
             list.set_Item(i, (object)new PgpPbeEncryptedData((SymmetricKeyEncSessionPacket)list.get_Item(i), data));
         }
         else
         {
             list.set_Item(i, (object)new PgpPublicKeyEncryptedData((PublicKeyEncSessionPacket)list.get_Item(i), data));
         }
     }
 }
示例#16
0
        internal static PublicKeyPacket ReadPublicKeyPacket(BcpgInputStream bcpgInput)
        {
            Packet packet = bcpgInput.ReadPacket();

            if (!(packet is PublicKeyPacket))
            {
                throw new IOException("unexpected packet in stream: " + packet);
            }

            return((PublicKeyPacket)packet);
        }
        public PgpLiteralData(
            BcpgInputStream bcpgInput)
        {
            Packet packet = bcpgInput.ReadPacket();

            if (!(packet is LiteralDataPacket))
            {
                throw new IOException("unexpected packet in stream: " + packet);
            }

            this.data = (LiteralDataPacket)packet;
        }
示例#18
0
        public PgpMarker(
            BcpgInputStream bcpgInput)
        {
            Packet packet = bcpgInput.ReadPacket();

            if (!(packet is MarkerPacket))
            {
                throw new IOException("unexpected packet in stream: " + packet);
            }

            this.data = (MarkerPacket)packet;
        }
示例#19
0
        internal static void ReadUserIDs(
            BcpgInputStream bcpgInput,
            out IList ids,
            out IList idTrusts,
            out IList idSigs)
        {
            ids      = Platform.CreateArrayList();
            idTrusts = Platform.CreateArrayList();
            idSigs   = Platform.CreateArrayList();

            // EDDINGTON
            try
            {
                while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
                       bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
                {
                    Packet obj = bcpgInput.ReadPacket();
                    if (obj is UserIdPacket)
                    {
                        UserIdPacket id = (UserIdPacket)obj;
                        ids.Add(id.GetId());
                    }
                    else
                    {
                        UserAttributePacket user = (UserAttributePacket)obj;
                        ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                    }

                    idTrusts.Add(
                        ReadOptionalTrustPacket(bcpgInput));

                    idSigs.Add(
                        ReadSignaturesAndTrust(bcpgInput));
                }
            }
            catch (Exception ex)
            {
                // EDDINGTON
                logger.Debug("ReadUserIDs: Exception occured: {0}", ex.Message);
                foreach (var id in ids)
                {
                    var sid = id.ToString();
                    if (id is UserIdPacket)
                    {
                        sid = ((UserIdPacket)id).GetId();
                    }

                    logger.Debug("ReadUserIDs: ID: {0}", sid);
                }

                throw;
            }
        }
示例#20
0
		internal static void ReadUserIDs(
			BcpgInputStream	bcpgInput,
			out IList       ids,
			out IList       idTrusts,
			out IList       idSigs)
		{
			ids = Platform.CreateArrayList();
            idTrusts = Platform.CreateArrayList();
            idSigs = Platform.CreateArrayList();

			// EDDINGTON
			try
			{
				while (bcpgInput.NextPacketTag() == PacketTag.UserId
					|| bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
				{
					Packet obj = bcpgInput.ReadPacket();
					if (obj is UserIdPacket)
					{
						UserIdPacket id = (UserIdPacket)obj;
						ids.Add(id.GetId());
					}
					else
					{
						UserAttributePacket user = (UserAttributePacket) obj;
						ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
					}

					idTrusts.Add(
						ReadOptionalTrustPacket(bcpgInput));

					idSigs.Add(
						ReadSignaturesAndTrust(bcpgInput));
				}
			}
			catch (Exception ex)
			{
				// EDDINGTON
				logger.Debug("ReadUserIDs: Exception occured: {0}", ex.Message);
				foreach (var id in ids)
				{
					var sid = id.ToString();
					if (id is UserIdPacket)
						sid = ((UserIdPacket)id).GetId();

					logger.Debug("ReadUserIDs: ID: {0}", sid);
				}

				throw;
			}
		}
		public PgpEncryptedDataList(
            BcpgInputStream bcpgInput)
        {
            while (bcpgInput.NextPacketTag() == PacketTag.PublicKeyEncryptedSession
                || bcpgInput.NextPacketTag() == PacketTag.SymmetricKeyEncryptedSessionKey)
            {
                list.Add(bcpgInput.ReadPacket());
            }

			data = (InputStreamPacket)bcpgInput.ReadPacket();

			for (int i = 0; i != list.Count; i++)
            {
                if (list[i] is SymmetricKeyEncSessionPacket)
                {
                    list[i] = new PgpPbeEncryptedData((SymmetricKeyEncSessionPacket) list[i], data);
                }
                else
                {
                    list[i] = new PgpPublicKeyEncryptedData((PublicKeyEncSessionPacket) list[i], data);
                }
            }
        }
示例#22
0
 internal static IList ReadSignaturesAndTrust(BcpgInputStream bcpgInput)
 {
     try
     {
         IList list = Platform.CreateArrayList();
         while (bcpgInput.NextPacketTag() == PacketTag.Signature)
         {
             SignaturePacket sigPacket   = (SignaturePacket)bcpgInput.ReadPacket();
             TrustPacket     trustPacket = ReadOptionalTrustPacket(bcpgInput);
             list.Add(new PgpSignature(sigPacket, trustPacket));
         }
         return(list);
     }
     catch (PgpException ex)
     {
         throw new IOException("can't create signature object: " + ex.Message, ex);
     }
 }
示例#23
0
 internal static global::System.Collections.IList ReadSignaturesAndTrust(BcpgInputStream bcpgInput)
 {
     //IL_0049: Unknown result type (might be due to invalid IL or missing references)
     try
     {
         global::System.Collections.IList list = Platform.CreateArrayList();
         while (bcpgInput.NextPacketTag() == PacketTag.Signature)
         {
             SignaturePacket sigPacket   = (SignaturePacket)bcpgInput.ReadPacket();
             TrustPacket     trustPacket = ReadOptionalTrustPacket(bcpgInput);
             list.Add((object)new PgpSignature(sigPacket, trustPacket));
         }
         return(list);
     }
     catch (PgpException ex)
     {
         throw new IOException("can't create signature object: " + ((global::System.Exception)ex).get_Message(), (global::System.Exception)ex);
     }
 }
        internal static IList<IPgpSignature> ReadSignaturesAndTrust(BcpgInputStream bcpgInput)
        {
            try
            {
                var sigList = Platform.CreateArrayList<IPgpSignature>();

                while (bcpgInput.NextPacketTag() == PacketTag.Signature)
                {
                    var signaturePacket = (SignaturePacket)bcpgInput.ReadPacket();
                    var trustPacket = ReadOptionalTrustPacket(bcpgInput);

                    sigList.Add(new PgpSignature(signaturePacket, trustPacket));
                }

                return sigList;
            }
            catch (PgpException e)
            {
                throw new IOException("can't create signature object: " + e.Message, e);
            }
        }
示例#25
0
 internal static void ReadUserIDs(BcpgInputStream bcpgInput, out IList ids, out IList idTrusts, out IList idSigs)
 {
     ids      = Platform.CreateArrayList();
     idTrusts = Platform.CreateArrayList();
     idSigs   = Platform.CreateArrayList();
     while (bcpgInput.NextPacketTag() == PacketTag.UserId || bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
     {
         Packet packet = bcpgInput.ReadPacket();
         if (packet is UserIdPacket)
         {
             UserIdPacket userIdPacket = (UserIdPacket)packet;
             ids.Add(userIdPacket.GetId());
         }
         else
         {
             UserAttributePacket userAttributePacket = (UserAttributePacket)packet;
             ids.Add(new PgpUserAttributeSubpacketVector(userAttributePacket.GetSubpackets()));
         }
         idTrusts.Add(ReadOptionalTrustPacket(bcpgInput));
         idSigs.Add(ReadSignaturesAndTrust(bcpgInput));
     }
 }
    public PgpPublicKeyRing(Stream inputStream)
    {
        keys = Platform.CreateArrayList();
        BcpgInputStream bcpgInputStream = BcpgInputStream.Wrap(inputStream);
        PacketTag       packetTag       = bcpgInputStream.NextPacketTag();

        if (packetTag != PacketTag.PublicKey && packetTag != PacketTag.PublicSubkey)
        {
            int num = (int)packetTag;
            throw new IOException("public key ring doesn't start with public key tag: tag 0x" + num.ToString("X"));
        }
        PublicKeyPacket publicPk = (PublicKeyPacket)bcpgInputStream.ReadPacket();
        TrustPacket     trustPk  = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);
        IList           keySigs  = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);

        PgpKeyRing.ReadUserIDs(bcpgInputStream, out IList ids, out IList idTrusts, out IList idSigs);
        keys.Add(new PgpPublicKey(publicPk, trustPk, keySigs, ids, idTrusts, idSigs));
        while (bcpgInputStream.NextPacketTag() == PacketTag.PublicSubkey)
        {
            keys.Add(ReadSubkey(bcpgInputStream));
        }
    }
示例#27
0
        public PgpPublicKeyRing(Stream inputStream)
        {
            //IL_0041: Unknown result type (might be due to invalid IL or missing references)
            keys = Platform.CreateArrayList();
            BcpgInputStream bcpgInputStream = BcpgInputStream.Wrap(inputStream);
            PacketTag       packetTag       = bcpgInputStream.NextPacketTag();

            if (packetTag != PacketTag.PublicKey && packetTag != PacketTag.PublicSubkey)
            {
                int num = (int)packetTag;
                throw new IOException("public key ring doesn't start with public key tag: tag 0x" + num.ToString("X"));
            }
            PublicKeyPacket publicPk = (PublicKeyPacket)bcpgInputStream.ReadPacket();
            TrustPacket     trustPk  = PgpKeyRing.ReadOptionalTrustPacket(bcpgInputStream);

            global::System.Collections.IList keySigs = PgpKeyRing.ReadSignaturesAndTrust(bcpgInputStream);
            PgpKeyRing.ReadUserIDs(bcpgInputStream, out var ids, out var idTrusts, out var idSigs);
            keys.Add((object)new PgpPublicKey(publicPk, trustPk, keySigs, ids, idTrusts, idSigs));
            while (bcpgInputStream.NextPacketTag() == PacketTag.PublicSubkey)
            {
                keys.Add((object)ReadSubkey(bcpgInputStream));
            }
        }
示例#28
0
        public PgpSecretKeyRing(
            Stream inputStream)
        {
            this.keys         = Platform.CreateArrayList();
            this.extraPubKeys = Platform.CreateArrayList();

            BcpgInputStream bcpgInput = BcpgInputStream.Wrap(inputStream);

            PacketTag initialTag = bcpgInput.NextPacketTag();

            if (initialTag != PacketTag.SecretKey && initialTag != PacketTag.SecretSubkey)
            {
                throw new IOException("secret key ring doesn't start with secret key tag: "
                                      + "tag 0x" + ((int)initialTag).ToString("X"));
            }

            SecretKeyPacket secret = (SecretKeyPacket)bcpgInput.ReadPacket();

            //
            // ignore GPG comment packets if found.
            //
            while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
            {
                bcpgInput.ReadPacket();
            }

            TrustPacket trust = ReadOptionalTrustPacket(bcpgInput);

            // revocation and direct signatures
            IList keySigs = ReadSignaturesAndTrust(bcpgInput);

            IList ids, idTrusts, idSigs;

            ReadUserIDs(bcpgInput, out ids, out idTrusts, out idSigs);

            keys.Add(new PgpSecretKey(secret, new PgpPublicKey(secret.PublicKeyPacket, trust, keySigs, ids, idTrusts, idSigs)));


            // Read subkeys
            while (bcpgInput.NextPacketTag() == PacketTag.SecretSubkey ||
                   bcpgInput.NextPacketTag() == PacketTag.PublicSubkey)
            {
                if (bcpgInput.NextPacketTag() == PacketTag.SecretSubkey)
                {
                    SecretSubkeyPacket sub = (SecretSubkeyPacket)bcpgInput.ReadPacket();

                    //
                    // ignore GPG comment packets if found.
                    //
                    while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
                    {
                        bcpgInput.ReadPacket();
                    }

                    TrustPacket subTrust = ReadOptionalTrustPacket(bcpgInput);
                    IList       sigList  = ReadSignaturesAndTrust(bcpgInput);

                    keys.Add(new PgpSecretKey(sub, new PgpPublicKey(sub.PublicKeyPacket, subTrust, sigList)));
                }
                else
                {
                    PublicSubkeyPacket sub = (PublicSubkeyPacket)bcpgInput.ReadPacket();

                    TrustPacket subTrust = ReadOptionalTrustPacket(bcpgInput);
                    IList       sigList  = ReadSignaturesAndTrust(bcpgInput);

                    extraPubKeys.Add(new PgpPublicKey(sub, subTrust, sigList));
                }
            }
        }
示例#29
0
        public PgpPublicKeyRing(
            Stream inputStream)
        {
            this.keys = new ArrayList();

            BcpgInputStream bcpgInput = BcpgInputStream.Wrap(inputStream);

            PacketTag initialTag = bcpgInput.NextPacketTag();

            if (initialTag != PacketTag.PublicKey && initialTag != PacketTag.PublicSubkey)
            {
                throw new IOException(
                          "public key ring doesn't start with public key tag: " +
                          "tag 0x" + initialTag.ToString("X"));
            }

            PublicKeyPacket pubPk;
            TrustPacket     trustPk;
            ArrayList       keySigs = new ArrayList();
            ArrayList       ids     = new ArrayList();
            ArrayList       idTrust = new ArrayList();
            ArrayList       idSigs  = new ArrayList();

            pubPk   = (PublicKeyPacket)bcpgInput.ReadPacket();
            trustPk = null;
            if (bcpgInput.NextPacketTag() == PacketTag.Trust)
            {
                trustPk = (TrustPacket)bcpgInput.ReadPacket();
            }

            //
            // direct signatures and revocations
            //
            while (bcpgInput.NextPacketTag() == PacketTag.Signature)
            {
                try
                {
                    SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();

                    if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                    {
                        keySigs.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
                    }
                    else
                    {
                        keySigs.Add(new PgpSignature(s));
                    }
                }
                catch (PgpException e)
                {
                    throw new IOException("can't create signature object: " + e.Message + ", cause: " + e.InnerException.ToString());
                }
            }

            while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
                   bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
            {
                object obj = bcpgInput.ReadPacket();

                if (obj is UserIdPacket)
                {
                    UserIdPacket id = (UserIdPacket)obj;
                    ids.Add(id.GetId());
                }
                else
                {
                    UserAttributePacket user = (UserAttributePacket)obj;
                    ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                }

                if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                {
                    idTrust.Add(bcpgInput.ReadPacket());
                }
                else
                {
                    idTrust.Add(null);
                }

                ArrayList sigList = new ArrayList();

                idSigs.Add(sigList);

                while (bcpgInput.NextPacketTag() == PacketTag.Signature)
                {
                    try
                    {
                        SignaturePacket s    = (SignaturePacket)bcpgInput.ReadPacket();
                        PacketTag       next = bcpgInput.NextPacketTag();
                        TrustPacket     tp   = (next == PacketTag.Trust)
                            ?    (TrustPacket)bcpgInput.ReadPacket()
                            :    null;

                        PgpSignature pgpSig = new PgpSignature(s, tp);
                        sigList.Add(pgpSig);
                    }
                    catch (PgpException e)
                    {
                        throw new IOException("can't create signature object: " + e.Message + ", cause: " + e.InnerException.ToString());
                    }
                }
            }

            keys.Add(new PgpPublicKey(pubPk, trustPk, keySigs, ids, idTrust, idSigs));

            while (bcpgInput.NextPacketTag() == PacketTag.PublicSubkey)
            {
                PublicKeyPacket pk     = (PublicKeyPacket)bcpgInput.ReadPacket();
                TrustPacket     kTrust = null;

                if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                {
                    kTrust = (TrustPacket)bcpgInput.ReadPacket();
                }

                ArrayList sigList = new ArrayList();

                try
                {
                    //
                    // PGP 8 actually leaves out the signature.
                    //
                    while (bcpgInput.NextPacketTag() == PacketTag.Signature)
                    {
                        SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();

                        if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                        {
                            sigList.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
                        }
                        else
                        {
                            sigList.Add(new PgpSignature(s));
                        }
                    }
                }
                catch (PgpException e)
                {
                    throw new IOException("can't create signature object: " + e.Message + ", cause: " + e.InnerException.ToString());
                }

                keys.Add(new PgpPublicKey(pk, kTrust, sigList));
            }
        }
示例#30
0
 public PgpExperimental(
     BcpgInputStream bcpgIn)
 {
     p = (ExperimentalPacket)bcpgIn.ReadPacket();
 }
示例#31
0
 public PgpLiteralData(BcpgInputStream bcpgInput)
 {
     data = (LiteralDataPacket)bcpgInput.ReadPacket();
 }
示例#32
0
		public PgpLiteralData(
            BcpgInputStream bcpgInput)
        {
            data = (LiteralDataPacket) bcpgInput.ReadPacket();
        }
示例#33
0
		private byte	lastb; // Initial value anything but '\r'

		internal PgpSignature(
            BcpgInputStream bcpgInput)
            : this((SignaturePacket)bcpgInput.ReadPacket())
        {
        }
示例#34
0
 internal PgpOnePassSignature(
     BcpgInputStream bcpgInput)
     : this((OnePassSignaturePacket)bcpgInput.ReadPacket())
 {
 }
 internal PgpOnePassSignature(
     BcpgInputStream pIn) : this((OnePassSignaturePacket)pIn.ReadPacket())
 {
 }
示例#36
0
		public PgpCompressedData(
            BcpgInputStream bcpgInput)
        {
            data = (CompressedDataPacket) bcpgInput.ReadPacket();
        }
        internal static PgpPublicKey ReadSubkey(BcpgInputStream bcpgInput)
        {
            PublicKeyPacket	pk = (PublicKeyPacket) bcpgInput.ReadPacket();
            TrustPacket kTrust = ReadOptionalTrustPacket(bcpgInput);

            // PGP 8 actually leaves out the signature.
            IList sigList = ReadSignaturesAndTrust(bcpgInput);

            return new PgpPublicKey(pk, kTrust, sigList);
        }
示例#38
0
		public PgpMarker(
            BcpgInputStream bcpgIn)
        {
            p = (MarkerPacket) bcpgIn.ReadPacket();
        }
        public PgpSecretKeyRing(
            Stream inputStream)
        {
            this.keys = new ArrayList();

            BcpgInputStream bcpgInput  = BcpgInputStream.Wrap(inputStream);
            PacketTag       initialTag = bcpgInput.NextPacketTag();

            if (initialTag != PacketTag.SecretKey && initialTag != PacketTag.SecretSubkey)
            {
                throw new IOException(
                          "secret key ring doesn't start with secret key tag: " +
                          "tag 0x" + initialTag.ToString("X"));
            }

            SecretKeyPacket secret   = (SecretKeyPacket)bcpgInput.ReadPacket();
            TrustPacket     trust    = null;
            ArrayList       keySigs  = new ArrayList();
            ArrayList       ids      = new ArrayList();
            ArrayList       idTrusts = new ArrayList();
            ArrayList       idSigs   = new ArrayList();
            IDigest         sha;

            try
            {
                sha = DigestUtilities.GetDigest("SHA1");
            }
            catch (Exception)
            {
                throw new IOException("can't find SHA1 digest");
            }

            //
            // ignore GPG comment packets if found.
            //
            while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
            {
                bcpgInput.ReadPacket();
            }

            if (bcpgInput.NextPacketTag() == PacketTag.Trust)
            {
                trust = (TrustPacket)bcpgInput.ReadPacket();  // ignore for the moment
            }

            //
            // revocation and direct signatures
            //
            while (bcpgInput.NextPacketTag() == PacketTag.Signature)
            {
                try
                {
                    keySigs.Add(new PgpSignature(bcpgInput));
                }
                catch (PgpException e)
                {
                    throw new IOException("can't create signature object: " + e.Message + ", cause: " + e.InnerException.ToString());
                }
            }

            while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
                   bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
            {
                object    obj     = bcpgInput.ReadPacket();
                ArrayList sigList = new ArrayList();

                if (obj is UserIdPacket)
                {
                    UserIdPacket id = (UserIdPacket)obj;
                    ids.Add(id.GetId());
                }
                else
                {
                    UserAttributePacket user = (UserAttributePacket)obj;
                    ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
                }

                if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                {
                    idTrusts.Add(bcpgInput.ReadPacket());
                }
                else
                {
                    idTrusts.Add(null);
                }

                idSigs.Add(sigList);

                while (bcpgInput.NextPacketTag() == PacketTag.Signature)
                {
                    SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();

                    if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                    {
                        sigList.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
                    }
                    else
                    {
                        sigList.Add(new PgpSignature(s));
                    }
                }
            }

            keys.Add(new PgpSecretKey(secret, trust, sha, keySigs, ids, idTrusts, idSigs));

            while (bcpgInput.NextPacketTag() == PacketTag.SecretSubkey)
            {
                SecretSubkeyPacket sub      = (SecretSubkeyPacket)bcpgInput.ReadPacket();
                TrustPacket        subTrust = null;
                ArrayList          sigList  = new ArrayList();

                //
                // ignore GPG comment packets if found.
                //
                while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
                {
                    bcpgInput.ReadPacket();
                }

                if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                {
                    subTrust = (TrustPacket)bcpgInput.ReadPacket();
                }

                while (bcpgInput.NextPacketTag() == PacketTag.Signature)
                {
                    SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();

                    if (bcpgInput.NextPacketTag() == PacketTag.Trust)
                    {
                        sigList.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
                    }
                    else
                    {
                        sigList.Add(new PgpSignature(s));
                    }
                }

                keys.Add(new PgpSecretKey(sub, subTrust, sha, sigList));
            }
        }
示例#40
0
 public PgpMarker(
     BcpgInputStream bcpgIn)
 {
     p = (MarkerPacket)bcpgIn.ReadPacket();
 }
示例#41
0
		public PgpExperimental(
			BcpgInputStream bcpgIn)
		{
			p = (ExperimentalPacket) bcpgIn.ReadPacket();
		}
示例#42
0
 public PgpCompressedData(
     BcpgInputStream bcpgInput)
 {
     data = (CompressedDataPacket)bcpgInput.ReadPacket();
 }