class OpenSSL::Timestamp::Request

Ermöglicht das Erstellen von Zeitstempelanfragen oder das Parsen vorhandener Anfragen. Ein Request wird auch benötigt, um Zeitstempel von Grund auf mit Factory zu erstellen. Bei der Erstellung von Grund auf werden einige Standardwerte gesetzt.

version wird auf 1 gesetzt
cert_requested wird auf true gesetzt
algorithm, message_imprint, policy_id und nonce werden auf false gesetzt

Öffentliche Klassenmethoden

OpenSSL::Timestamp::Request.new(file) → request

OpenSSL::Timestamp::Request.new(string) → request

OpenSSL::Timestamp::Request.new → leere Anfrage

Source

static VALUE
ossl_ts_req_initialize(int argc, VALUE *argv, VALUE self)
{
    TS_REQ *ts_req = DATA_PTR(self);
    BIO *in;
    VALUE arg;

    if(rb_scan_args(argc, argv, "01", &arg) == 0) {
        return self;
    }

    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(&arg);
    ts_req = d2i_TS_REQ_bio(in, &ts_req);
    BIO_free(in);
    if (!ts_req) {
        DATA_PTR(self) = NULL;
        ossl_raise(eTimestampError, "Error when decoding the timestamp request");
    }
    DATA_PTR(self) = ts_req;

    return self;
}

Beim Erstellen eines Request mit dem Parameter File oder string muss die entsprechende File oder string DER-kodiert sein.

Öffentliche Instanzmethoden

algorithm → string

Source

static VALUE
ossl_ts_req_get_algorithm(VALUE self)
{
    TS_REQ *req;
    TS_MSG_IMPRINT *mi;
    X509_ALGOR *algor;
    const ASN1_OBJECT *obj;

    GetTSRequest(self, req);
    mi = TS_REQ_get_msg_imprint(req);
    algor = TS_MSG_IMPRINT_get_algo(mi);
    X509_ALGOR_get0(&obj, NULL, NULL, algor);
    return ossl_asn1obj_to_string(obj);
}

Gibt den "kurzen Namen" des Objektidentifikators zurück, der den Algorithmus repräsentiert, der zur Erstellung des Hashwerts des Nachrichtenabdrucks verwendet wurde.

algorithm = "string" → string

Source

static VALUE
ossl_ts_req_set_algorithm(VALUE self, VALUE algo)
{
    TS_REQ *req;
    TS_MSG_IMPRINT *mi;
    ASN1_OBJECT *obj;
    X509_ALGOR *algor;

    GetTSRequest(self, req);
    obj = ossl_to_asn1obj(algo);
    mi = TS_REQ_get_msg_imprint(req);
    algor = TS_MSG_IMPRINT_get_algo(mi);
    if (!X509_ALGOR_set0(algor, obj, V_ASN1_NULL, NULL)) {
        ASN1_OBJECT_free(obj);
        ossl_raise(eTimestampError, "X509_ALGOR_set0");
    }

    return algo;
}

Ermöglicht das Festlegen des Objektidentifikators oder des "kurzen Namens" des Algorithmus, der zur Erstellung des Hashwerts des Nachrichtenabdrucks verwendet wurde.

Beispiel

request.algorithm = "SHA1"

cert_requested = boolean → true oder false

Source

static VALUE
ossl_ts_req_set_cert_requested(VALUE self, VALUE requested)
{
    TS_REQ *req;

    GetTSRequest(self, req);
    TS_REQ_set_cert_req(req, RTEST(requested));

    return requested;
}

Gibt an, ob die Antwort das Zertifikat der Zeitstempelautorität enthalten soll oder nicht. Der Standardwert ist true.

cert_requested? → true oder false

Source

static VALUE
ossl_ts_req_get_cert_requested(VALUE self)
{
    TS_REQ *req;

    GetTSRequest(self, req);
    return TS_REQ_get_cert_req(req) ? Qtrue: Qfalse;
}

Gibt an, ob die Antwort das Zertifikat der Zeitstempelautorität enthalten soll oder nicht.

message_imprint → string oder nil

Source

static VALUE
ossl_ts_req_get_msg_imprint(VALUE self)
{
    TS_REQ *req;
    TS_MSG_IMPRINT *mi;
    ASN1_OCTET_STRING *hashed_msg;
    VALUE ret;

    GetTSRequest(self, req);
    mi = TS_REQ_get_msg_imprint(req);
    hashed_msg = TS_MSG_IMPRINT_get_msg(mi);

    ret = asn1str_to_str(hashed_msg);

    return ret;
}

Gibt den Nachrichtenabdruck (Hashwert) der zu signierenden Daten zurück.

message_imprint = "string" → string

Source

static VALUE
ossl_ts_req_set_msg_imprint(VALUE self, VALUE hash)
{
    TS_REQ *req;
    TS_MSG_IMPRINT *mi;
    StringValue(hash);

    GetTSRequest(self, req);
    mi = TS_REQ_get_msg_imprint(req);
    if (!TS_MSG_IMPRINT_set_msg(mi, (unsigned char *)RSTRING_PTR(hash), RSTRING_LENINT(hash)))
        ossl_raise(eTimestampError, "TS_MSG_IMPRINT_set_msg");

    return hash;
}

Setzt den Hashwert des Nachrichtenabdrucks.

nonce → BN oder nil

Source

static VALUE
ossl_ts_req_get_nonce(VALUE self)
{
    TS_REQ *req;
    const ASN1_INTEGER * nonce;

    GetTSRequest(self, req);
    if (!(nonce = TS_REQ_get_nonce(req)))
        return Qnil;
    return asn1integer_to_num(nonce);
}

Gibt die einmalig verwendete Zahl (Nonce) zurück, die der Server in seiner Antwort enthalten soll.

nonce = number → BN

Source

static VALUE
ossl_ts_req_set_nonce(VALUE self, VALUE num)
{
    TS_REQ *req;
    ASN1_INTEGER *nonce;
    int ok;

    GetTSRequest(self, req);
    nonce = num_to_asn1integer(num, NULL);
    ok = TS_REQ_set_nonce(req, nonce);
    ASN1_INTEGER_free(nonce);
    if (!ok)
        ossl_raise(eTimestampError, NULL);
    return num;
}

Legt die einmalig verwendete Zahl (Nonce) fest, die der Server in seiner Antwort enthalten soll. Wenn die Nonce gesetzt ist, muss der Server denselben Nonce-Wert in einer gültigen Response zurückgeben.

policy_id → string oder nil

Source

static VALUE
ossl_ts_req_get_policy_id(VALUE self)
{
    TS_REQ *req;

    GetTSRequest(self, req);
    if (!TS_REQ_get_policy_id(req))
        return Qnil;
    return ossl_asn1obj_to_string(TS_REQ_get_policy_id(req));
}

Gibt den "kurzen Namen" des Objektidentifikators zurück, der die Zeitstempelrichtlinie repräsentiert, unter der der Server den Zeitstempel erstellen soll.

policy_id = "string" → string

Source

static VALUE
ossl_ts_req_set_policy_id(VALUE self, VALUE oid)
{
    TS_REQ *req;
    ASN1_OBJECT *obj;
    int ok;

    GetTSRequest(self, req);
    obj = ossl_to_asn1obj(oid);
    ok = TS_REQ_set_policy_id(req, obj);
    ASN1_OBJECT_free(obj);
    if (!ok)
        ossl_raise(eTimestampError, "TS_REQ_set_policy_id");

    return oid;
}

Ermöglicht das Festlegen des Objektidentifikators, der die Zeitstempelrichtlinie repräsentiert, unter der der Server den Zeitstempel erstellen soll. Dies kann nil bleiben, was bedeutet, dass der Zeitstempelserver den Zeitstempel anhand einer Standardrichtlinie ausstellt.

Beispiel

request.policy_id = "1.2.3.4.5"

to_der → DER-kodierter String

Source

static VALUE
ossl_ts_req_to_der(VALUE self)
{
    TS_REQ *req;
    TS_MSG_IMPRINT *mi;
    X509_ALGOR *algo;
    const ASN1_OBJECT *obj;
    ASN1_OCTET_STRING *hashed_msg;

    GetTSRequest(self, req);
    mi = TS_REQ_get_msg_imprint(req);

    algo = TS_MSG_IMPRINT_get_algo(mi);
    X509_ALGOR_get0(&obj, NULL, NULL, algo);
    if (OBJ_obj2nid(obj) == NID_undef)
        ossl_raise(eTimestampError, "Message imprint missing algorithm");

    hashed_msg = TS_MSG_IMPRINT_get_msg(mi);
    if (!ASN1_STRING_length(hashed_msg))
        ossl_raise(eTimestampError, "Message imprint missing hashed message");

    return asn1_to_der((void *)req, (int (*)(void *, unsigned char **))i2d_TS_REQ);
}

Kodiert diesen Request in DER.

to_text ()

Source

static VALUE
ossl_ts_req_to_text(VALUE self)
{
    TS_REQ *req;
    BIO *out;

    GetTSRequest(self, req);

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

    if (!TS_REQ_print_bio(out, req)) {
        BIO_free(out);
        ossl_raise(eTimestampError, NULL);
    }

    return ossl_membio2str(out);
}

version → Integer

Source

static VALUE
ossl_ts_req_get_version(VALUE self)
{
    TS_REQ *req;

    GetTSRequest(self, req);
    return LONG2NUM(TS_REQ_get_version(req));
}

Gibt die Version dieser Anfrage zurück. 1 ist der Standardwert.

version = number → Integer

Source

static VALUE
ossl_ts_req_set_version(VALUE self, VALUE version)
{
    TS_REQ *req;
    long ver;

    if ((ver = NUM2LONG(version)) < 0)
        ossl_raise(eTimestampError, "version must be >= 0!");
    GetTSRequest(self, req);
    if (!TS_REQ_set_version(req, ver))
        ossl_raise(eTimestampError, "TS_REQ_set_version");

    return version;
}

Legt die Versionsnummer für diese Request fest. Dies sollte für konforme Server 1 sein.