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));
                }
            }
        }
Beispiel #2
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));
            }
        }
Beispiel #3
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 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));
            }
        }
Beispiel #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));
            }
        }
        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));
            }
        }
		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 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;
            }
        }
		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;
			}
		}
Beispiel #10
0
		internal static TrustPacket ReadOptionalTrustPacket(
			BcpgInputStream bcpgInput)
		{
			return (bcpgInput.NextPacketTag() == PacketTag.Trust)
				?	(TrustPacket) bcpgInput.ReadPacket()
				:	null;
		}
 internal static TrustPacket ReadOptionalTrustPacket(
     BcpgInputStream bcpgInput)
 {
     return((bcpgInput.NextPacketTag() == PacketTag.Trust)
                         ?       (TrustPacket)bcpgInput.ReadPacket()
                         :       null);
 }
 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);
         }
     }
 }
 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));
        }
    }
		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);
                }
            }
        }
Beispiel #16
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));
            }
        }
 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);
     }
 }
Beispiel #18
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);
     }
 }
 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));
         }
     }
 }
        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);
            }
        }
Beispiel #21
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));
                }
            }
        }
    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));
            }
        }
    }
        /// <summary>Return the next object in the stream, or null if the end is reached.</summary>
        /// <exception cref="IOException">On a parse error</exception>
        public PgpObject NextPgpObject()
        {
            PacketTag tag = bcpgIn.NextPacketTag();

            if ((int)tag == -1)
            {
                return(null);
            }

            switch (tag)
            {
            case PacketTag.Signature:
            {
                IList l = Platform.CreateArrayList();

                while (bcpgIn.NextPacketTag() == PacketTag.Signature)
                {
                    try
                    {
                        l.Add(new PgpSignature(bcpgIn));
                    }
                    catch (PgpException e)
                    {
                        throw new IOException("can't create signature object: " + e);
                    }
                }

                PgpSignature[] sigs = new PgpSignature[l.Count];
                for (int i = 0; i < l.Count; ++i)
                {
                    sigs[i] = (PgpSignature)l[i];
                }
                return(new PgpSignatureList(sigs));
            }

            case PacketTag.SecretKey:
                try
                {
                    return(new PgpSecretKeyRing(bcpgIn));
                }
                catch (PgpException e)
                {
                    throw new IOException("can't create secret key object: " + e);
                }

            case PacketTag.PublicKey:
                return(new PgpPublicKeyRing(bcpgIn));

            // TODO Make PgpPublicKey a PgpObject or return a PgpPublicKeyRing
//				case PacketTag.PublicSubkey:
//					return PgpPublicKeyRing.ReadSubkey(bcpgIn);
            case PacketTag.CompressedData:
                return(new PgpCompressedData(bcpgIn));

            case PacketTag.LiteralData:
                return(new PgpLiteralData(bcpgIn));

            case PacketTag.PublicKeyEncryptedSession:
            case PacketTag.SymmetricKeyEncryptedSessionKey:
                return(new PgpEncryptedDataList(bcpgIn));

            case PacketTag.OnePassSignature:
            {
                IList l = Platform.CreateArrayList();

                while (bcpgIn.NextPacketTag() == PacketTag.OnePassSignature)
                {
                    try
                    {
                        l.Add(new PgpOnePassSignature(bcpgIn));
                    }
                    catch (PgpException e)
                    {
                        throw new IOException("can't create one pass signature object: " + e);
                    }
                }

                PgpOnePassSignature[] sigs = new PgpOnePassSignature[l.Count];
                for (int i = 0; i < l.Count; ++i)
                {
                    sigs[i] = (PgpOnePassSignature)l[i];
                }
                return(new PgpOnePassSignatureList(sigs));
            }

            case PacketTag.Marker:
                return(new PgpMarker(bcpgIn));

            case PacketTag.Experimental1:
            case PacketTag.Experimental2:
            case PacketTag.Experimental3:
            case PacketTag.Experimental4:
                return(new PgpExperimental(bcpgIn));
            }

            throw new IOException("unknown object in stream " + bcpgIn.NextPacketTag());
        }
Beispiel #24
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));
                }
            }
        }
        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));
            }
        }
        }        //IL_0003: Unknown result type (might be due to invalid IL or missing references)

        //IL_000d: Expected O, but got Unknown


        public PgpObject NextPgpObject()
        {
            //IL_0091: Unknown result type (might be due to invalid IL or missing references)
            //IL_00fe: Unknown result type (might be due to invalid IL or missing references)
            //IL_0160: Unknown result type (might be due to invalid IL or missing references)
            //IL_01e5: Unknown result type (might be due to invalid IL or missing references)
            PacketTag packetTag = bcpgIn.NextPacketTag();

            if (packetTag == (PacketTag)(-1))
            {
                return(null);
            }
            switch (packetTag)
            {
            case PacketTag.Signature:
            {
                global::System.Collections.IList list2 = Platform.CreateArrayList();
                while (bcpgIn.NextPacketTag() == PacketTag.Signature)
                {
                    try
                    {
                        list2.Add((object)new PgpSignature(bcpgIn));
                    }
                    catch (PgpException ex3)
                    {
                        throw new IOException(string.Concat((object)"can't create signature object: ", (object)ex3));
                    }
                }
                PgpSignature[] array2 = new PgpSignature[((global::System.Collections.ICollection)list2).get_Count()];
                for (int j = 0; j < ((global::System.Collections.ICollection)list2).get_Count(); j++)
                {
                    array2[j] = (PgpSignature)list2.get_Item(j);
                }
                return(new PgpSignatureList(array2));
            }

            case PacketTag.SecretKey:
                try
                {
                    return(new PgpSecretKeyRing((Stream)(object)bcpgIn));
                }
                catch (PgpException ex2)
                {
                    throw new IOException(string.Concat((object)"can't create secret key object: ", (object)ex2));
                }

            case PacketTag.PublicKey:
                return(new PgpPublicKeyRing((Stream)(object)bcpgIn));

            case PacketTag.CompressedData:
                return(new PgpCompressedData(bcpgIn));

            case PacketTag.LiteralData:
                return(new PgpLiteralData(bcpgIn));

            case PacketTag.PublicKeyEncryptedSession:
            case PacketTag.SymmetricKeyEncryptedSessionKey:
                return(new PgpEncryptedDataList(bcpgIn));

            case PacketTag.OnePassSignature:
            {
                global::System.Collections.IList list = Platform.CreateArrayList();
                while (bcpgIn.NextPacketTag() == PacketTag.OnePassSignature)
                {
                    try
                    {
                        list.Add((object)new PgpOnePassSignature(bcpgIn));
                    }
                    catch (PgpException ex)
                    {
                        throw new IOException(string.Concat((object)"can't create one pass signature object: ", (object)ex));
                    }
                }
                PgpOnePassSignature[] array = new PgpOnePassSignature[((global::System.Collections.ICollection)list).get_Count()];
                for (int i = 0; i < ((global::System.Collections.ICollection)list).get_Count(); i++)
                {
                    array[i] = (PgpOnePassSignature)list.get_Item(i);
                }
                return(new PgpOnePassSignatureList(array));
            }

            case PacketTag.Marker:
                return(new PgpMarker(bcpgIn));

            case PacketTag.Experimental1:
            case PacketTag.Experimental2:
            case PacketTag.Experimental3:
            case PacketTag.Experimental4:
                return(new PgpExperimental(bcpgIn));

            default:
                throw new IOException(string.Concat((object)"unknown object in stream ", (object)bcpgIn.NextPacketTag()));
            }
        }
Beispiel #27
0
    public PgpObject NextPgpObject()
    {
        PacketTag packetTag = bcpgIn.NextPacketTag();

        if (packetTag == (PacketTag)(-1))
        {
            return(null);
        }
        switch (packetTag)
        {
        case PacketTag.Signature:
        {
            IList list2 = Platform.CreateArrayList();
            while (bcpgIn.NextPacketTag() == PacketTag.Signature)
            {
                try
                {
                    list2.Add(new PgpSignature(bcpgIn));
                }
                catch (PgpException arg3)
                {
                    throw new IOException("can't create signature object: " + arg3);
                }
            }
            PgpSignature[] array2 = new PgpSignature[list2.Count];
            for (int j = 0; j < list2.Count; j++)
            {
                array2[j] = (PgpSignature)list2[j];
            }
            return(new PgpSignatureList(array2));
        }

        case PacketTag.SecretKey:
            try
            {
                return(new PgpSecretKeyRing(bcpgIn));
            }
            catch (PgpException arg2)
            {
                throw new IOException("can't create secret key object: " + arg2);
            }

        case PacketTag.PublicKey:
            return(new PgpPublicKeyRing(bcpgIn));

        case PacketTag.CompressedData:
            return(new PgpCompressedData(bcpgIn));

        case PacketTag.LiteralData:
            return(new PgpLiteralData(bcpgIn));

        case PacketTag.PublicKeyEncryptedSession:
        case PacketTag.SymmetricKeyEncryptedSessionKey:
            return(new PgpEncryptedDataList(bcpgIn));

        case PacketTag.OnePassSignature:
        {
            IList list = Platform.CreateArrayList();
            while (bcpgIn.NextPacketTag() == PacketTag.OnePassSignature)
            {
                try
                {
                    list.Add(new PgpOnePassSignature(bcpgIn));
                }
                catch (PgpException arg)
                {
                    throw new IOException("can't create one pass signature object: " + arg);
                }
            }
            PgpOnePassSignature[] array = new PgpOnePassSignature[list.Count];
            for (int i = 0; i < list.Count; i++)
            {
                array[i] = (PgpOnePassSignature)list[i];
            }
            return(new PgpOnePassSignatureList(array));
        }

        case PacketTag.Marker:
            return(new PgpMarker(bcpgIn));

        case PacketTag.Experimental1:
        case PacketTag.Experimental2:
        case PacketTag.Experimental3:
        case PacketTag.Experimental4:
            return(new PgpExperimental(bcpgIn));

        default:
            throw new IOException("unknown object in stream " + bcpgIn.NextPacketTag());
        }
    }
Beispiel #28
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));
            }
        }
Beispiel #29
0
        /// <summary>Return the next object in the stream, or null if the end is reached.</summary>
        /// <exception cref="IOException">On a parse error</exception>
        public PgpObject NextPgpObject()
        {
            var tag = _bcpgIn.NextPacketTag();

            if ((int)tag == -1)
            {
                return(null);
            }

            switch (tag)
            {
            case PacketTag.Signature:
            {
                var sigs = new List <PgpSignature>();
                while (_bcpgIn.NextPacketTag() == PacketTag.Signature)
                {
                    try
                    {
                        sigs.Add(new PgpSignature(_bcpgIn));
                    }
                    catch (PgpException e)
                    {
                        throw new IOException("can't create signature object: " + e);
                    }
                }

                return(new PgpSignatureList(sigs.ToArray()));
            }

            case PacketTag.SecretKey:
                try
                {
                    return(new PgpSecretKeyRing(_bcpgIn));
                }
                catch (PgpException e)
                {
                    throw new IOException("can't create secret key object: " + e);
                }

            case PacketTag.PublicKey:
                return(new PgpPublicKeyRing(_bcpgIn));

            case PacketTag.CompressedData:
                return(new PgpCompressedData(_bcpgIn));

            case PacketTag.LiteralData:
                return(new PgpLiteralData(_bcpgIn));

            case PacketTag.PublicKeyEncryptedSession:
            case PacketTag.SymmetricKeyEncryptedSessionKey:
                return(new PgpEncryptedDataList(_bcpgIn));

            case PacketTag.OnePassSignature:
            {
                var sigs = new List <PgpOnePassSignature>();
                while (_bcpgIn.NextPacketTag() == PacketTag.OnePassSignature)
                {
                    try
                    {
                        sigs.Add(new PgpOnePassSignature(_bcpgIn));
                    }
                    catch (PgpException e)
                    {
                        throw new IOException("can't create one pass signature object: " + e);
                    }
                }

                return(new PgpOnePassSignatureList(sigs.ToArray()));
            }

            case PacketTag.Marker:
                return(new PgpMarker(_bcpgIn));

            case PacketTag.Experimental1:
            case PacketTag.Experimental2:
            case PacketTag.Experimental3:
            case PacketTag.Experimental4:
                return(new PgpExperimental(_bcpgIn));
            }

            throw new IOException("unknown object in stream " + _bcpgIn.NextPacketTag());
        }