Create a tool, that given a set of certificates, can automatically build a chain and validate a signature inside the context of that chain

[fxdgear]

from a conversation with @reaperhulk he suggested I open an issue here for discussions.

[reaperhulk]

@fxdgear's use case here is JWT, which allows you to have a certificate chain (https://tools.ietf.org/html/draft-ietf-jose-json-web-signature-41#section-4.1.6). To validate the token you need to build a chain from the signing certificate up to the root (which you presumably have obtained via some out of band method outside the JSON web token payload).

[alex]

@reaperhulk this uses standard X.509 certificate verification right? So we need some sort of certificate store API, and then the ability to verify that a cert (or chain I guess?) is signed by it?

[reaperhulk]

Yep. Of course, the devil is in the level of rigor we decide to employ. (OCSP/CRL checks all the way up the chain? If so, how do we do that without building an API that requires implicit outbound network egress)

[alex]

I think it needs to be configurable (sadly) somehow, unclear what (if any)
the defaults should be.

On Fri, Feb 13, 2015 at 6:09 PM, Paul Kehrer notifications@github.com
wrote:

Yep. Of course, the devil is in the level of rigor we decide to employ.
(OCSP/CRL checks all the way up the chain? If so, how do we do that without
building an API that requires implicit outbound network egress)

—
Reply to this email directly or view it on GitHub
#1660 (comment).

"I disapprove of what you say, but I will defend to the death your right to
say it." -- Evelyn Beatrice Hall (summarizing Voltaire)
"The people's good is the highest law." -- Cicero
GPG Key fingerprint: 125F 5C67 DFE9 4084

[Ayrx]

Does "tool" in this context mean a command-line program or just an API in cryptography?

[alex]

API

On Fri, Feb 13, 2015 at 7:53 PM, Terry Chia notifications@github.com
wrote:

Does "tool" in this context mean a command-line program or just an API in
cryptography?

—
Reply to this email directly or view it on GitHub
#1660 (comment).

"I disapprove of what you say, but I will defend to the death your right to
say it." -- Evelyn Beatrice Hall (summarizing Voltaire)
"The people's good is the highest law." -- Cicero
GPG Key fingerprint: 125F 5C67 DFE9 4084

[wbolster]

Please default to not making any network connections under any circumstances. Implicit network access has lead to so many unexpected problems in other software libraries, e.g. XML parsers, or I/O related API's that automatically resolve urls.

[schlenk]

As OCSP and CRL requests are usually cached for their validity time, it would be bad to do direct network calls. Much better to have some kind of API where you register some kind of CRL or OCSP resolver that does the work in whatever way needed (e.g. hooking into the platform specific OCSP/CRL infrastructure would be an option on windows).

[schlenk]

I just needed something like this.

For some basic verification support one could use the X509_verify_cert() API exposed by the openssl binding already. It lacks on the CRL side of things (as the needed functions are not wrapped right now) and the Lookup API isn't wrapped either, so one can only verify already existing certs or things available in the filesystem.

But once you have those, one can get started with something like the following (the pyOpenSSL wrappers around cryptography are just a minor detour here, could easily be replaced by the appropriate cryptography.x509 things if available).

from OpenSSL.crypto import _raise_current_error, _ffi, _lib, X509, X509Store

class X509StoreContext(object):
    """ X509_STORE_CTX API Wrapper

        This wraps the X509_STORE_CTX API of the openssl
        library to do certificate validation.
    """

    def __init__(self, trust_store):
        store_ctx = _lib.X509_STORE_CTX_new()
        if store_ctx == _ffi.NULL:
            raise RuntimeError("Failed to allocate context")
        self._ctx = _ffi.gc(store_ctx, _lib.X509_STORE_CTX_free)

        if not isinstance(trust_store, X509Store):
            raise TypeError()

        ok = _lib.X509_STORE_CTX_init(self._ctx,
                                      trust_store._store,
                                      _ffi.NULL,
                                      _ffi.NULL)
        if not ok:
            _raise_current_error()

        chain = _lib.sk_X509_new_null()
        self._chain = _ffi.gc(chain, _lib.sk_X509_free)

        def verify_cb(ok, ctx):
            return self._verify_callback(ok, ctx)

        self._callback = _ffi.callback(
            "int(int, X509_STORE_CTX *)",
            verify_cb)

        ok = _lib.X509_STORE_CTX_set_verify_cb(self._ctx, self._callback)

    def _verify_callback(self, ok, ctx):
        try:
            # get the cert we looked at
            err_cert = _lib.X509_STORE_CTX_get_current_cert(ctx)
            # any error codes
            err = _lib.X509_STORE_CTX_get_error(ctx)
            # the current depth (aka distance from the Trust anchor)
            depth = _lib.X509_STORE_CTX_get_error_depth(ctx)
            # the subject name of the current cert
            name = _lib.X509_get_subject_name(err_cert)
            result_buffer = _ffi.new("char[]", 512)
            format_result = _lib.X509_NAME_oneline(name, result_buffer,
                                                   len(result_buffer))
            if format_result == _ffi.NULL:
                name_str = "Unknown"
            else:
                name_str = _ffi.string(result_buffer)
            print("CALLBACK: Preverify={0} Error={1} Depth={2} Subject={3}".format(ok, err, depth, name_str))
        except Exception as exc:
            # exception is always failed
            return 0
        else:
            return ok

    def add_chain_certs(self, certs):
        for cert in certs:
            if not isinstance(cert, X509):
                raise TypeError()
        for cert in certs:
            ok = _lib.sk_X509_push(self._chain, cert._x509)
            if ok == 0:
                raise RuntimeError("Failed to push stack")

    def verify_cert(self, cert):
        if not isinstance(cert, X509):
            raise TypeError()

        if _lib.sk_X509_num(self._chain) > 0:
            _lib.X509_STORE_CTX_set_chain(self._ctx, self._chain)

        _lib.X509_STORE_CTX_set_cert(self._ctx, cert._x509)

        ok = _lib.X509_verify_cert(self._ctx)
        if ok <= 0:
            # handle error
            # via X509_STORE_CTX_get_error()
            pass
        return ok

[alex]

Closing this as a dupe of #2381