Ejemplo n.º 1
0
        private void UpdateFromMem(IntPtr keysigPtr)
        {
            var keysig = (_gpgme_key_sig)Marshal.PtrToStructure(keysigPtr,
                                                                typeof(_gpgme_key_sig));

            Revoked    = keysig.revoked;
            Expired    = keysig.expired;
            Invalid    = keysig.invalid;
            Exportable = keysig.exportable;

            PubkeyAlgorithm = (KeyAlgorithm)keysig.pubkey_algo;

            KeyId   = Gpgme.PtrToStringAnsi(keysig.keyid);
            Uid     = Gpgme.PtrToStringAnsi(keysig.uid);
            Name    = Gpgme.PtrToStringAnsi(keysig.name);
            Comment = Gpgme.PtrToStringAnsi(keysig.comment);
            Email   = Gpgme.PtrToStringAnsi(keysig.email);

            _timestamp = (long)keysig.timestamp;
            _expires   = (long)keysig.expires;

            Status   = keysig.status;
            SigClass = keysig.sig_class;

            if (keysig.notations != IntPtr.Zero)
            {
                Notations = new SignatureNotation(keysig.notations);
            }

            if (keysig.next != IntPtr.Zero)
            {
                Next = new KeySignature(keysig.next);
            }
        }
Ejemplo n.º 2
0
        private void UpdateFromMem(IntPtr keysigPtr)
        {
            _gpgme_key_sig keysig = (_gpgme_key_sig)Marshal.PtrToStructure(keysigPtr,
                                                                           typeof(_gpgme_key_sig));

            revoked    = keysig.revoked;
            expired    = keysig.expired;
            invalid    = keysig.invalid;
            exportable = keysig.exportable;

            pubkey_algo = (KeyAlgorithm)keysig.pubkey_algo;

            keyid   = Gpgme.PtrToStringAnsi(keysig.keyid);
            uid     = Gpgme.PtrToStringAnsi(keysig.uid);
            name    = Gpgme.PtrToStringAnsi(keysig.name);
            comment = Gpgme.PtrToStringAnsi(keysig.comment);
            email   = Gpgme.PtrToStringAnsi(keysig.email);

            timestamp = (long)keysig.timestamp;
            expires   = (long)keysig.expires;

            status    = keysig.status;
            sig_class = (long)keysig.sig_class;

            if (keysig.notations != (IntPtr)0)
            {
                notations = new SignatureNotation(keysig.notations);
            }

            if (keysig.next != (IntPtr)0)
            {
                next = new KeySignature(keysig.next);
            }
        }
        private void UpdateFromMem(IntPtr sigPtr)
        {
            /* Work around memory layout problem (bug?) on Windows systems
             * with libgpgme <= 1.1.8
             * //_gpgme_signature sig = new _gpgme_signature();
             *
             */
            if (!libgpgme.IsWindows ||
                (Gpgme.Version.Major >= 1 &&
                 Gpgme.Version.Minor >= 2)
                )
            {
                _gpgme_signature unixsig = new _gpgme_signature();
                Marshal.PtrToStructure(sigPtr, unixsig);

                summary         = (SignatureSummary)unixsig.summary;
                fpr             = Gpgme.PtrToStringUTF8(unixsig.fpr);
                status          = unixsig.status;
                timestamp       = unixsig.timestamp;
                exp_timestamp   = unixsig.exp_timestamp;
                validity        = (Validity)unixsig.validity;
                validity_reason = unixsig.validity_reason;
                pubkey_algo     = (KeyAlgorithm)unixsig.pubkey_algo;
                hash_algo       = (HashAlgorithm)unixsig.hash_algo;
                pka_address     = Gpgme.PtrToStringUTF8(unixsig.pka_address);
                wrong_key_usage = unixsig.wrong_key_usage;
                pka_trust       = (PkaStatus)unixsig.pka_trust;
                chain_model     = unixsig.chain_model;

                if (unixsig.notations != IntPtr.Zero)
                {
                    notations = new SignatureNotation(unixsig.notations);
                }

                if (unixsig.next != IntPtr.Zero)
                {
                    next = new Signature(unixsig.next);
                }
            }
            else
            {
                _gpgme_signature_windows winsig = new _gpgme_signature_windows();
                Marshal.PtrToStructure(sigPtr, winsig);

                summary         = (SignatureSummary)winsig.summary;
                fpr             = Gpgme.PtrToStringUTF8(winsig.fpr);
                status          = winsig.status;
                timestamp       = winsig.timestamp;
                exp_timestamp   = winsig.exp_timestamp;
                validity        = (Validity)winsig.validity;
                validity_reason = winsig.validity_reason;
                pubkey_algo     = (KeyAlgorithm)winsig.pubkey_algo;
                hash_algo       = (HashAlgorithm)winsig.hash_algo;
                pka_address     = Gpgme.PtrToStringUTF8(winsig.pka_address);
                wrong_key_usage = winsig.wrong_key_usage;
                pka_trust       = (PkaStatus)winsig.pka_trust;
                chain_model     = winsig.chain_model;

                if (winsig.notations != IntPtr.Zero)
                {
                    notations = new SignatureNotation(winsig.notations);
                }

                if (winsig.next != IntPtr.Zero)
                {
                    next = new Signature(winsig.next);
                }
            }
        }
Ejemplo n.º 4
0
        private void UpdateFromMem(IntPtr sigPtr)
        {
            /* Work around memory layout problem (bug?) on Windows systems
             * with libgpgme <= 1.1.8
             * //_gpgme_signature sig = new _gpgme_signature();
             *
             */
            if (!libgpgme.IsWindows ||
                (Gpgme.Version.Major >= 1 &&
                 Gpgme.Version.Minor >= 2)
                )
            {
                var unixsig = new _gpgme_signature();
                Marshal.PtrToStructure(sigPtr, unixsig);

                Summary          = (SignatureSummary)unixsig.summary;
                Fingerprint      = Gpgme.PtrToStringUTF8(unixsig.fpr);
                _status          = unixsig.status;
                _timestamp       = unixsig.timestamp;
                _exp_timestamp   = unixsig.exp_timestamp;
                Validity         = (Validity)unixsig.validity;
                _validity_reason = unixsig.validity_reason;
                PubkeyAlgorithm  = (KeyAlgorithm)unixsig.pubkey_algo;
                HashAlgorithm    = (HashAlgorithm)unixsig.hash_algo;
                PKAAddress       = Gpgme.PtrToStringUTF8(unixsig.pka_address);
                WrongKeyUsage    = unixsig.wrong_key_usage;
                PKATrust         = unixsig.pka_trust;
                ChainModel       = unixsig.chain_model;

                if (unixsig.notations != IntPtr.Zero)
                {
                    Notations = new SignatureNotation(unixsig.notations);
                }

                if (unixsig.next != IntPtr.Zero)
                {
                    Next = new Signature(unixsig.next);
                }
            }
            else
            {
                var winsig = new _gpgme_signature_windows();
                Marshal.PtrToStructure(sigPtr, winsig);

                Summary          = (SignatureSummary)winsig.summary;
                Fingerprint      = Gpgme.PtrToStringUTF8(winsig.fpr);
                _status          = winsig.status;
                _timestamp       = winsig.timestamp;
                _exp_timestamp   = winsig.exp_timestamp;
                Validity         = (Validity)winsig.validity;
                _validity_reason = winsig.validity_reason;
                PubkeyAlgorithm  = (KeyAlgorithm)winsig.pubkey_algo;
                HashAlgorithm    = (HashAlgorithm)winsig.hash_algo;
                PKAAddress       = Gpgme.PtrToStringUTF8(winsig.pka_address);
                WrongKeyUsage    = winsig.wrong_key_usage;
                PKATrust         = winsig.pka_trust;
                ChainModel       = winsig.chain_model;

                if (winsig.notations != IntPtr.Zero)
                {
                    Notations = new SignatureNotation(winsig.notations);
                }

                if (winsig.next != IntPtr.Zero)
                {
                    Next = new Signature(winsig.next);
                }
            }
        }