Esempio n. 1
0
 /// <summary>
 /// Returns true if the given object is the "this" key.
 /// </summary>
 /// <remarks>
 /// The keys are compared by there fingerprint. If the fingerprint
 /// is the same, the keys are said to be the same.
 /// </remarks>
 /// <param name="o">An object that shall be compared against
 /// this.</param>
 /// <returns>True if the giben object o is the same as the
 /// "this" key.</returns>
 public override bool Equals(object o)
 {
     if (o is TransportablePublicKey)
     {
         TransportablePublicKey tpkKey = (TransportablePublicKey)o;
         return(tpkKey.PrimaryKey.Fingerprint == this.PrimaryKey.Fingerprint);
     }
     return(false);
 }
Esempio n. 2
0
        public static TransportablePublicKey[] SplitKeys(string strRadix64)
        {
            ArrayList alKeys = new ArrayList();

            Packet[] pPackets = Packet.ParsePackets(strRadix64);

            byte[] bOneKey = new byte[0];
            for (int i = 0; i < pPackets.Length; i++)
            {
                if (pPackets[i] is PublicKeyPacket)
                {
                    PublicKeyPacket pkpKey = (PublicKeyPacket)pPackets[i];
                    if ((pkpKey.Content == ContentTypes.PublicKey) && (bOneKey.Length > 10))
                    {
                        TransportablePublicKey tpkKey = new TransportablePublicKey(Radix64.Encode(bOneKey, true));
                        alKeys.Add(tpkKey);
                        bOneKey = new byte[0];
                    }
                }
                byte[] bPacket = pPackets[i].Generate();
                byte[] bTmpKey = new byte[bOneKey.Length];
                bOneKey.CopyTo(bTmpKey, 0);
                bOneKey = new byte[bOneKey.Length + bPacket.Length];
                Array.Copy(bTmpKey, 0, bOneKey, 0, bTmpKey.Length);
                Array.Copy(bPacket, 0, bOneKey, bTmpKey.Length, bPacket.Length);
            }

            if (bOneKey.Length > 10)
            {
                TransportablePublicKey tpkKey = new TransportablePublicKey(Radix64.Encode(bOneKey, true));
                alKeys.Add(tpkKey);
            }

            TransportablePublicKey[] tpkKeys = new TransportablePublicKey[alKeys.Count];
            int         iCount = 0;
            IEnumerator ieKeys = alKeys.GetEnumerator();

            while (ieKeys.MoveNext())
            {
                if (!(ieKeys.Current is TransportablePublicKey))
                {
                    continue;
                }

                tpkKeys[iCount++] = (TransportablePublicKey)ieKeys.Current;
            }

            return(tpkKeys);
        }
Esempio n. 3
0
        /// <summary>
        /// Verifies the signature of this signed message.
        /// </summary>
        /// <remarks>No remarks</remarks>
        /// <returns>Returns a SignatureStatusType that contains
        /// whether the signature was valid, invalid or could not be
        /// verified</returns>
        /// <param name="pkrKeyRing">The public keyring containing
        /// all keys known to the local system.</param>
        public SignatureStatusTypes Verify(PublicKeyRing pkrKeyRing)
        {
            TransportablePublicKey tpkKey = pkrKeyRing.Find(spSignature.KeyID);

            if (tpkKey == null)
            {
                return(SignatureStatusTypes.Signing_Key_Not_Available);
            }

            PublicKeyPacket pkpKey = tpkKey.FindKey(spSignature.KeyID);

            spSignature.Verify(lmSignedMessage.Binary, pkpKey);

            return(spSignature.SignatureStatus);
        }
        /// <summary>
        /// Validates all certificates belonging the the given public key packet
        /// and the current certifications.
        /// </summary>
        /// <remarks>
        /// So far only works with v4 signatures!
        /// </remarks>
        /// <param name="pkpKey">The public key packet to which the userid
        /// belongs.</param>
        /// <param name="pkrRing">A keyring containing all public keys known to
        /// the system. This is neccessary in order to verify the signatures.
        /// </param>
        public void Validate(PublicKeyPacket pkpKey, PublicKeyRing pkrRing)
        {
            IEnumerator ieCertificates = Certificates.GetEnumerator();

            while (ieCertificates.MoveNext())
            {
                if (ieCertificates.Current is SignaturePacket)
                {
                    SignaturePacket spCert = (SignaturePacket)ieCertificates.Current;

                    TransportablePublicKey tkpSigningKey = pkrRing.Find(spCert.KeyID);
                    if (tkpSigningKey == null)
                    {
                        continue;
                    }
                    PublicKeyPacket pkpSigningKey = tkpSigningKey.PrimaryKey;

                    if (spCert.Version == SignaturePacketVersionNumbers.v4)
                    {
                        byte[] bKey = new byte[pkpKey.Body.Length + 3];
                        bKey[0] = 0x99;
                        bKey[1] = (byte)((pkpKey.Body.Length >> 8) & 0xFF);
                        bKey[2] = (byte)(pkpKey.Body.Length & 0xFF);
                        Array.Copy(pkpKey.Body, 0, bKey, 3, pkpKey.Body.Length);

                        byte[] bUserID = new byte[UserID.Body.Length + 5];
                        bUserID[0] = 0xb4;
                        bUserID[1] = (byte)((UserID.Body.Length >> 24) & 0xFF);
                        bUserID[2] = (byte)((UserID.Body.Length >> 16) & 0xFF);
                        bUserID[3] = (byte)((UserID.Body.Length >> 8) & 0xFF);
                        bUserID[4] = (byte)(UserID.Body.Length & 0xFF);
                        Array.Copy(UserID.Body, 0, bUserID, 5, UserID.Body.Length);

                        byte[] bData = new byte[bUserID.Length + bKey.Length];
                        Array.Copy(bKey, 0, bData, 0, bKey.Length);
                        Array.Copy(bUserID, 0, bData, bKey.Length, bUserID.Length);

                        spCert.Verify(bData, pkpSigningKey);
                    }
                    else
                    {
                        //TODO: Add code for v3 Signature verification
                    }
                }
            }
        }