class OpenSSL::Timestamp::Response

Eine unveränderliche und schreibgeschützte Darstellung einer Zeitstempelantwort, die von einem Zeitstempelserver nach Erhalt einer zugehörigen Request zurückgegeben wird. Ermöglicht den Zugriff auf spezifische Informationen über die Antwort und auch die Überprüfung der Response.

Constants

GRANTED: Zeigt eine erfolgreiche Antwort an. Gleich 0.
GRANTED_WITH_MODS: Zeigt eine erfolgreiche Antwort an, die wahrscheinlich Änderungen gegenüber der ursprünglichen Anfrage enthält. Gleich 1.
REJECTION: Zeigt einen Fehler an. Es wurde kein Zeitstempel-Token erstellt. Gleich 2.
REVOCATION_NOTIFICATION: Zeigt einen Fehler an. Es wurde kein Zeitstempel-Token erstellt. Ein Zertifikat wurde widerrufen. Gleich 5.
REVOCATION_WARNING: Zeigt einen Fehler an. Es wurde kein Zeitstempel-Token erstellt. Der Widerruf eines Zertifikats steht unmittelbar bevor. Gleich 4.
WAITING: Zeigt einen Fehler an. Es wurde kein Zeitstempel-Token erstellt. Gleich 3.

Öffentliche Klassenmethoden

OpenSSL::Timestamp::Response.new(file) → response

OpenSSL::Timestamp::Response.new(string) → response

Source

static VALUE
ossl_ts_resp_initialize(VALUE self, VALUE der)
{
    TS_RESP *ts_resp = DATA_PTR(self);
    BIO *in;

    der = ossl_to_der_if_possible(der);
    in  = ossl_obj2bio(&der);
    ts_resp = d2i_TS_RESP_bio(in, &ts_resp);
    BIO_free(in);
    if (!ts_resp) {
        DATA_PTR(self) = NULL;
        ossl_raise(eTimestampError, "Error when decoding the timestamp response");
    }
    DATA_PTR(self) = ts_resp;

    return self;
}

Erstellt eine Response aus einem File- oder string-Parameter. Die entsprechende File oder string muss DER-kodiert sein. Bitte beachten Sie, dass Response eine unveränderliche schreibgeschützte Klasse ist. Wenn Sie Zeitstempel erstellen möchten, verwenden Sie stattdessen die Factory.

Öffentliche Instanzmethoden

failure_info → nil oder Symbol

Source

static VALUE
ossl_ts_resp_get_failure_info(VALUE self)
{
    TS_RESP *resp;
    TS_STATUS_INFO *si;
    const ASN1_BIT_STRING *fi;

    GetTSResponse(self, resp);
    si = TS_RESP_get_status_info(resp);
    fi = TS_STATUS_INFO_get0_failure_info(si);
    if (!fi)
        return Qnil;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_BAD_ALG))
        return sBAD_ALG;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_BAD_REQUEST))
        return sBAD_REQUEST;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_BAD_DATA_FORMAT))
        return sBAD_DATA_FORMAT;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_TIME_NOT_AVAILABLE))
        return sTIME_NOT_AVAILABLE;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_UNACCEPTED_POLICY))
        return sUNACCEPTED_POLICY;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_UNACCEPTED_EXTENSION))
        return sUNACCEPTED_EXTENSION;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_ADD_INFO_NOT_AVAILABLE))
        return sADD_INFO_NOT_AVAILABLE;
    if (ASN1_BIT_STRING_get_bit(fi, TS_INFO_SYSTEM_FAILURE))
        return sSYSTEM_FAILURE;

    ossl_raise(eTimestampError, "Unrecognized failure info.");
}

Wenn kein Zeitstempel-Token erstellt wurde, enthält dieses Feld weitere Informationen über den Grund, warum die Erstellung der Antwort fehlgeschlagen ist. Die Methode gibt entweder nil zurück (die Anfrage war erfolgreich und ein Zeitstempel-Token wurde erstellt) oder eines der folgenden Elemente:

:BAD_ALG - Zeigt an, dass der Zeitstempelserver den im Request verwendeten Nachrichten-Imprint-Algorithmus ablehnt
:BAD_REQUEST - Zeigt an, dass der Zeitstempelserver die Request nicht ordnungsgemäß verarbeiten konnte
:BAD_DATA_FORMAT - Zeigt an, dass der Zeitstempelserver bestimmte Daten in der Request nicht parsen konnte
:TIME_NOT_AVAILABLE - Zeigt an, dass der Server nicht auf seine Zeitquelle zugreifen konnte
:UNACCEPTED_POLICY - Zeigt an, dass die angeforderte Policy-ID vom Zeitstempelserver nicht erkannt oder unterstützt wird
:UNACCEPTED_EXTENSIION - Zeigt an, dass eine Erweiterung in der Request vom Zeitstempelserver nicht unterstützt wird
:ADD_INFO_NOT_AVAILABLE - Zeigt an, dass zusätzliche angeforderte Informationen entweder nicht verstanden oder derzeit nicht verfügbar sind
:SYSTEM_FAILURE - Die Erstellung von Timestamp ist aufgrund eines internen Fehlers auf dem Zeitstempelserver fehlgeschlagen

status → BN (nie nil)

Source

static VALUE
ossl_ts_resp_get_status(VALUE self)
{
    TS_RESP *resp;
    TS_STATUS_INFO *si;
    const ASN1_INTEGER *st;

    GetTSResponse(self, resp);
    si = TS_RESP_get_status_info(resp);
    st = TS_STATUS_INFO_get0_status(si);

    return asn1integer_to_num(st);
}

Gibt einen der Werte GRANTED, GRANTED_WITH_MODS, REJECTION, WAITING, REVOCATION_WARNING oder REVOCATION_NOTIFICATION zurück. Ein Zeitstempel-Token wurde nur erstellt, wenn status gleich GRANTED oder GRANTED_WITH_MODS ist.

status_text → Array von Strings oder nil

Source

static VALUE
ossl_ts_resp_get_status_text(VALUE self)
{
    TS_RESP *resp;
    TS_STATUS_INFO *si;
    const STACK_OF(ASN1_UTF8STRING) *text;
    ASN1_UTF8STRING *current;
    int i;
    VALUE ret = rb_ary_new();

    GetTSResponse(self, resp);
    si = TS_RESP_get_status_info(resp);
    if ((text = TS_STATUS_INFO_get0_text(si))) {
        for (i = 0; i < sk_ASN1_UTF8STRING_num(text); i++) {
            current = sk_ASN1_UTF8STRING_value(text, i);
            rb_ary_push(ret, asn1str_to_str(current));
        }
    }

    return ret;
}

Im Falle eines Fehlers kann dieses Feld ein Array von Strings enthalten, die den Ursprung des Fehlers näher beschreiben.

to_der → string

Source

static VALUE
ossl_ts_resp_to_der(VALUE self)
{
    TS_RESP *resp;

    GetTSResponse(self, resp);
    return asn1_to_der((void *)resp, (int (*)(void *, unsigned char **))i2d_TS_RESP);
}

Gibt die Response in DER-kodierter Form zurück.

to_text ()

Source

static VALUE
ossl_ts_resp_to_text(VALUE self)
{
    TS_RESP *resp;
    BIO *out;

    GetTSResponse(self, resp);

    out = BIO_new(BIO_s_mem());
    if (!out) ossl_raise(eTimestampError, NULL);

    if (!TS_RESP_print_bio(out, resp)) {
        BIO_free(out);
        ossl_raise(eTimestampError, NULL);
    }

    return ossl_membio2str(out);
}

token → nil oder OpenSSL::PKCS7

Source

static VALUE
ossl_ts_resp_get_token(VALUE self)
{
    TS_RESP *resp;
    PKCS7 *p7;

    GetTSResponse(self, resp);
    if (!(p7 = TS_RESP_get_token(resp)))
        return Qnil;
    return ossl_pkcs7_new(p7);
}

Wenn ein Zeitstempel-Token vorhanden ist, wird es in Form eines OpenSSL::PKCS7 zurückgegeben.

token_info → nil oder OpenSSL::Timestamp::TokenInfo

Source

static VALUE
ossl_ts_resp_get_token_info(VALUE self)
{
    TS_RESP *resp;
    TS_TST_INFO *info, *copy;
    VALUE obj;

    GetTSResponse(self, resp);
    if (!(info = TS_RESP_get_tst_info(resp)))
        return Qnil;

    obj = NewTSTokenInfo(cTimestampTokenInfo);

    if (!(copy = TS_TST_INFO_dup(info)))
        ossl_raise(eTimestampError, NULL);

    SetTSTokenInfo(obj, copy);

    return obj;
}

Ruft die Token-Informationen der Antwort ab, falls vorhanden.

tsa_certificate → OpenSSL::X509::Certificate oder nil

Source

static VALUE
ossl_ts_resp_get_tsa_certificate(VALUE self)
{
    TS_RESP *resp;
    PKCS7 *p7;
    PKCS7_SIGNER_INFO *ts_info;
    X509 *cert;

    GetTSResponse(self, resp);
    if (!(p7 = TS_RESP_get_token(resp)))
        return Qnil;
    ts_info = sk_PKCS7_SIGNER_INFO_value(p7->d.sign->signer_info, 0);
    cert = PKCS7_cert_from_signer_info(p7, ts_info);
    if (!cert)
        return Qnil;
    return ossl_x509_new(cert);
}

Wenn in der Request angegeben wurde, das TSA-Zertifikat anzufordern (Request#cert_requested = true), enthält dieses Feld das Zertifikat der Zeitstempelautorität.

verify(Request, root_store) → Response

verify(Request, root_store, [intermediate_cert]) → Response

Source

static VALUE
ossl_ts_resp_verify(int argc, VALUE *argv, VALUE self)
{
    VALUE ts_req, store, intermediates;
    TS_RESP *resp;
    TS_REQ *req;
    X509_STORE *x509st;
    TS_VERIFY_CTX *ctx;
    STACK_OF(X509) *x509inter = NULL;
    PKCS7* p7;
    X509 *cert;
    int status, i, ok;

    rb_scan_args(argc, argv, "21", &ts_req, &store, &intermediates);

    GetTSResponse(self, resp);
    GetTSRequest(ts_req, req);
    x509st = GetX509StorePtr(store);

    if (!(ctx = TS_REQ_to_TS_VERIFY_CTX(req, NULL))) {
        ossl_raise(eTimestampError, "Error when creating the verification context.");
    }

    if (!NIL_P(intermediates)) {
        x509inter = ossl_protect_x509_ary2sk(intermediates, &status);
        if (status) {
            TS_VERIFY_CTX_free(ctx);
            rb_jump_tag(status);
        }
    } else if (!(x509inter = sk_X509_new_null())) {
        TS_VERIFY_CTX_free(ctx);
        ossl_raise(eTimestampError, "sk_X509_new_null");
    }

    if (!(p7 = TS_RESP_get_token(resp))) {
        TS_VERIFY_CTX_free(ctx);
        sk_X509_pop_free(x509inter, X509_free);
        ossl_raise(eTimestampError, "TS_RESP_get_token");
    }
    for (i=0; i < sk_X509_num(p7->d.sign->cert); i++) {
        cert = sk_X509_value(p7->d.sign->cert, i);
        if (!sk_X509_push(x509inter, cert)) {
            sk_X509_pop_free(x509inter, X509_free);
            TS_VERIFY_CTX_free(ctx);
            ossl_raise(eTimestampError, "sk_X509_push");
        }
        X509_up_ref(cert);
    }

    if (!X509_STORE_up_ref(x509st)) {
        sk_X509_pop_free(x509inter, X509_free);
        TS_VERIFY_CTX_free(ctx);
        ossl_raise(eTimestampError, "X509_STORE_up_ref");
    }

#ifdef HAVE_TS_VERIFY_CTX_SET0_CERTS
    TS_VERIFY_CTX_set0_certs(ctx, x509inter);
    TS_VERIFY_CTX_set0_store(ctx, x509st);
#else
# if OSSL_OPENSSL_PREREQ(3, 0, 0) || OSSL_IS_LIBRESSL
    TS_VERIFY_CTX_set_certs(ctx, x509inter);
# else
    TS_VERIFY_CTS_set_certs(ctx, x509inter);
# endif
    TS_VERIFY_CTX_set_store(ctx, x509st);
#endif
    TS_VERIFY_CTX_add_flags(ctx, TS_VFY_SIGNATURE);

    ok = TS_RESP_verify_response(ctx, resp);
    TS_VERIFY_CTX_free(ctx);

    if (!ok)
        ossl_raise(eTimestampError, "TS_RESP_verify_response");

    return self;
}

Überprüft ein Zeitstempel-Token, indem die Signatur geprüft, die durch tsa_certificate implizierte Zertifikatskette validiert und die Konformität mit einer gegebenen Request geprüft wird. Obligatorische Parameter sind die Request, die zu dieser Response gehört, und ein OpenSSL::X509::Store vertrauenswürdiger Wurzeln.

Zwischenzertifikate können optional für die Erstellung der Zertifikatskette bereitgestellt werden. Diese Zwischenzertifikate müssen alle Instanzen von OpenSSL::X509::Certificate sein.

Wenn die Validierung fehlschlägt, können verschiedene Arten von Ausnahmen ausgelöst werden

TypeError, wenn die Typen nicht passen
TimestampError, wenn etwas mit dem Zeitstempel-Token selbst nicht stimmt, wenn es nicht konform mit der Request ist oder wenn die Validierung der Zeitstempel-Zertifikatskette fehlschlägt.