class OpenSSL::OCSP::Request

Ein OpenSSL::OCSP::Request enthält die Zertifikatsinformationen zur Bestimmung, ob ein Zertifikat widerrufen wurde oder nicht. Eine Request kann für ein Zertifikat oder aus einer anderweitig erstellten DER-kodierten Anfrage erstellt werden.

Öffentliche Klassenmethoden

OpenSSL::OCSP::Request.new → request

OpenSSL::OCSP::Request.new(request_der) → request

Source

static VALUE
ossl_ocspreq_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE arg;
    OCSP_REQUEST *req, *req_new;
    const unsigned char *p;

    rb_scan_args(argc, argv, "01", &arg);
    if(!NIL_P(arg)){
        GetOCSPReq(self, req);
        arg = ossl_to_der_if_possible(arg);
        StringValue(arg);
        p = (unsigned char *)RSTRING_PTR(arg);
        req_new = d2i_OCSP_REQUEST(NULL, &p, RSTRING_LEN(arg));
        if (!req_new)
            ossl_raise(eOCSPError, "d2i_OCSP_REQUEST");
        SetOCSPReq(self, req_new);
        OCSP_REQUEST_free(req);
    }

    return self;
}

Erstellt eine neue OpenSSL::OCSP::Request. Die Anfrage kann leer oder aus einem request_der-String erstellt werden.

Öffentliche Instanzmethoden

add_certid(certificate_id) → request

Source

static VALUE
ossl_ocspreq_add_certid(VALUE self, VALUE certid)
{
    OCSP_REQUEST *req;
    OCSP_CERTID *id, *id_new;

    GetOCSPReq(self, req);
    GetOCSPCertId(certid, id);

    if (!(id_new = OCSP_CERTID_dup(id)))
        ossl_raise(eOCSPError, "OCSP_CERTID_dup");
    if (!OCSP_request_add0_id(req, id_new)) {
        OCSP_CERTID_free(id_new);
        ossl_raise(eOCSPError, "OCSP_request_add0_id");
    }

    return self;
}

Fügt die certificate_id zur Anfrage hinzu.

add_nonce(nonce = nil) → request

Source

static VALUE
ossl_ocspreq_add_nonce(int argc, VALUE *argv, VALUE self)
{
    OCSP_REQUEST *req;
    VALUE val;
    int ret;

    rb_scan_args(argc, argv, "01", &val);
    if(NIL_P(val)) {
        GetOCSPReq(self, req);
        ret = OCSP_request_add1_nonce(req, NULL, -1);
    }
    else{
        StringValue(val);
        GetOCSPReq(self, req);
        ret = OCSP_request_add1_nonce(req, (unsigned char *)RSTRING_PTR(val), RSTRING_LENINT(val));
    }
    if(!ret) ossl_raise(eOCSPError, NULL);

    return self;
}

Fügt einen nonce zur OCSP-Anfrage hinzu. Wenn kein nonce angegeben wird, wird ein zufälliges generiert.

Der Nonce wird verwendet, um Replay-Angriffe zu verhindern, aber einige Server unterstützen ihn nicht.

certid → [certificate_id, ...]

Source

static VALUE
ossl_ocspreq_get_certid(VALUE self)
{
    OCSP_REQUEST *req;

    GetOCSPReq(self, req);
    int count = OCSP_request_onereq_count(req);
    if (count < 0)
        ossl_raise(eOCSPError, "OCSP_request_onereq_count");
    if (count == 0)
        return Qnil;

    VALUE ary = rb_ary_new_capa(count);
    for (int i = 0; i < count; i++) {
        OCSP_ONEREQ *one = OCSP_request_onereq_get0(req, i);
        OCSP_CERTID *cid = OCSP_onereq_get0_id(one);
        rb_ary_push(ary, ossl_ocspcid_new(cid));
    }

    return ary;
}

Gibt alle Zertifikat-IDs in dieser Anfrage zurück.

check_nonce(response) → result

Source

static VALUE
ossl_ocspreq_check_nonce(VALUE self, VALUE basic_resp)
{
    OCSP_REQUEST *req;
    OCSP_BASICRESP *bs;
    int res;

    GetOCSPReq(self, req);
    GetOCSPBasicRes(basic_resp, bs);
    res = OCSP_check_nonce(req, bs);

    return INT2NUM(res);
}

Prüft die Gültigkeit des Nonce für diese Anfrage und die response.

Der Rückgabewert ist einer der folgenden:

-1: nonce nur in der Anfrage vorhanden.
0: nonces beide vorhanden und nicht gleich.
1: nonces vorhanden und gleich.
2: nonces beide abwesend.
3: nonce nur in der Antwort vorhanden.

Bei den meisten Antworten können Clients result > 0 prüfen. Wenn ein Responder keine Nonces unterstützt, ist möglicherweise result.nonzero? erforderlich. Ein Ergebnis von 0 ist immer ein Fehler.

sign(cert, key, certs = nil, flags = 0, digest = nil) → self

Source

static VALUE
ossl_ocspreq_sign(int argc, VALUE *argv, VALUE self)
{
    VALUE signer_cert, signer_key, certs, flags, digest, md_holder;
    OCSP_REQUEST *req;
    X509 *signer;
    EVP_PKEY *key;
    STACK_OF(X509) *x509s = NULL;
    unsigned long flg = 0;
    const EVP_MD *md;
    int ret;

    rb_scan_args(argc, argv, "23", &signer_cert, &signer_key, &certs, &flags, &digest);
    GetOCSPReq(self, req);
    signer = GetX509CertPtr(signer_cert);
    key = GetPrivPKeyPtr(signer_key);
    if (!NIL_P(flags))
        flg = NUM2INT(flags);
    md = NIL_P(digest) ? NULL : ossl_evp_md_fetch(digest, &md_holder);
    if (NIL_P(certs))
        flg |= OCSP_NOCERTS;
    else
        x509s = ossl_x509_ary2sk(certs);

    ret = OCSP_request_sign(req, signer, key, md, x509s, flg);
    sk_X509_pop_free(x509s, X509_free);
    if (!ret)
        ossl_raise(eOCSPError, "OCSP_request_sign");

    return self;
}

Signiert diese OCSP-Anfrage mit cert, key und optional digest. Wenn digest nicht angegeben ist, wird SHA-1 verwendet. certs ist ein optionales Array von zusätzlichen Zertifikaten, die zusätzlich zum Signaturzertifikat in die Anfrage aufgenommen werden. Beachten Sie, dass, wenn certs nil ist oder nicht angegeben wird, das Flag OpenSSL::OCSP::NOCERTS aktiviert ist. Übergeben Sie ein leeres Array, um nur das Signaturzertifikat einzuschließen.

flags ist ein bitweises OR der folgenden Konstanten

OpenSSL::OCSP::NOCERTS: Fügt keine Zertifikate in die Anfrage ein. certs wird ignoriert.

signed? → true oder false

Source

static VALUE
ossl_ocspreq_signed_p(VALUE self)
{
    OCSP_REQUEST *req;

    GetOCSPReq(self, req);
    return OCSP_request_is_signed(req) ? Qtrue : Qfalse;
}

Gibt true zurück, wenn die Anfrage signiert ist, andernfalls false. Beachten Sie, dass die Gültigkeit der Signatur **nicht** geprüft wird. Verwenden Sie stattdessen verify, um dies zu überprüfen.

to_der ()

Source

static VALUE
ossl_ocspreq_to_der(VALUE self)
{
    OCSP_REQUEST *req;
    VALUE str;
    unsigned char *p;
    long len;

    GetOCSPReq(self, req);
    if((len = i2d_OCSP_REQUEST(req, NULL)) <= 0)
        ossl_raise(eOCSPError, NULL);
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if(i2d_OCSP_REQUEST(req, &p) <= 0)
        ossl_raise(eOCSPError, NULL);
    ossl_str_adjust(str, p);

    return str;
}

Gibt diese Anfrage als DER-kodierten String zurück

verify(certificates, store, flags = 0) → true oder false

Source

static VALUE
ossl_ocspreq_verify(int argc, VALUE *argv, VALUE self)
{
    VALUE certs, store, flags;
    OCSP_REQUEST *req;
    STACK_OF(X509) *x509s;
    X509_STORE *x509st;
    int flg, result;

    rb_scan_args(argc, argv, "21", &certs, &store, &flags);
    GetOCSPReq(self, req);
    x509st = GetX509StorePtr(store);
    flg = NIL_P(flags) ? 0 : NUM2INT(flags);
    x509s = ossl_x509_ary2sk(certs);
    result = OCSP_request_verify(req, x509s, x509st, flg);
    sk_X509_pop_free(x509s, X509_free);
    if (result <= 0)
        ossl_clear_error();

    return result > 0 ? Qtrue : Qfalse;
}

Verifiziert diese Anfrage mit den angegebenen certificates und store. certificates ist ein Array von OpenSSL::X509::Certificate, store ist ein OpenSSL::X509::Store.

Beachten Sie, dass false zurückgegeben wird, wenn die Anfrage keine Signatur hat. Verwenden Sie signed?, um zu prüfen, ob die Anfrage signiert ist oder nicht.