class OpenSSL::HMAC

OpenSSL::HMAC ermöglicht die Berechnung von Hash-based Message Authentication Code (HMAC). Es handelt sich um eine Art von Message Authentication Code (MAC), die eine Hash-Funktion in Kombination mit einem Schlüssel verwendet. HMAC kann zur Überprüfung der Integrität einer Nachricht sowie ihrer Authentizität verwendet werden.

OpenSSL::HMAC hat eine ähnliche Schnittstelle wie OpenSSL::Digest.

HMAC-SHA256 mit One-Shot-Schnittstelle

key = "key"
data = "message-to-be-authenticated"
mac = OpenSSL::HMAC.hexdigest("SHA256", key, data)
#=> "cddb0db23f469c8bf072b21fd837149bd6ace9ab771cceef14c9e517cc93282e"

HMAC-SHA256 mit inkrementeller Schnittstelle

data1 = File.binread("file1")
data2 = File.binread("file2")
key = "key"
hmac = OpenSSL::HMAC.new(key, 'SHA256')
hmac << data1
hmac << data2
mac = hmac.digest

Öffentliche Klassenmethoden

base64digest(digest, key, data) → aString

Source

# File ext/openssl/lib/openssl/hmac.rb, line 73
def base64digest(digest, key, data)
  [digest(digest, key, data)].pack("m0")
end

Gibt den Authentifizierungscode als Base64-kodierte Zeichenkette zurück. Der Parameter digest gibt den zu verwendenden Digest-Algorithmus an. Dies kann ein String sein, der den Algorithmusnamen repräsentiert, oder eine Instanz von OpenSSL::Digest.

Beispiel

key = 'key'
data = 'The quick brown fox jumps over the lazy dog'

hmac = OpenSSL::HMAC.base64digest('SHA1', key, data)
#=> "3nybhbi3iqa8ino29wqQcBydtNk="

digest(digest, key, data) → aString

Source

# File ext/openssl/lib/openssl/hmac.rb, line 35
def digest(digest, key, data)
  hmac = new(key, digest)
  hmac << data
  hmac.digest
end

Gibt den Authentifizierungscode als Binärzeichenkette zurück. Der Parameter digest gibt den zu verwendenden Digest-Algorithmus an. Dies kann ein String sein, der den Algorithmusnamen repräsentiert, oder eine Instanz von OpenSSL::Digest.

Beispiel

key = 'key'
data = 'The quick brown fox jumps over the lazy dog'

hmac = OpenSSL::HMAC.digest('SHA1', key, data)
#=> "\xDE|\x9B\x85\xB8\xB7\x8A\xA6\xBC\x8Az6\xF7\n\x90p\x1C\x9D\xB4\xD9"

hexdigest(digest, key, data) → aString

Source

# File ext/openssl/lib/openssl/hmac.rb, line 54
def hexdigest(digest, key, data)
  hmac = new(key, digest)
  hmac << data
  hmac.hexdigest
end

Gibt den Authentifizierungscode als Hex-kodierte Zeichenkette zurück. Der Parameter digest gibt den zu verwendenden Digest-Algorithmus an. Dies kann ein String sein, der den Algorithmusnamen repräsentiert, oder eine Instanz von OpenSSL::Digest.

Beispiel

key = 'key'
data = 'The quick brown fox jumps over the lazy dog'

hmac = OpenSSL::HMAC.hexdigest('SHA1', key, data)
#=> "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9"

new(key, digest) → hmac

Source

static VALUE
ossl_hmac_initialize(VALUE self, VALUE key, VALUE digest)
{
    EVP_MD_CTX *ctx;
    EVP_PKEY *pkey;
    const EVP_MD *md;
    VALUE md_holder;

    GetHMAC(self, ctx);
    StringValue(key);
    md = ossl_evp_md_fetch(digest, &md_holder);
    pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL,
                                        (unsigned char *)RSTRING_PTR(key),
                                        RSTRING_LENINT(key));
    if (!pkey)
        ossl_raise(eHMACError, "EVP_PKEY_new_raw_private_key");
    if (EVP_DigestSignInit(ctx, NULL, md, NULL, pkey) != 1) {
        EVP_PKEY_free(pkey);
        ossl_raise(eHMACError, "EVP_DigestSignInit");
    }
    rb_ivar_set(self, id_md_holder, md_holder);
    /* Decrement reference counter; EVP_MD_CTX still keeps it */
    EVP_PKEY_free(pkey);

    return self;
}

Gibt eine Instanz von OpenSSL::HMAC zurück, die mit dem zu verwendenden Schlüssel und Digest-Algorithmus eingerichtet ist. Die Instanz repräsentiert den Anfangszustand des Message Authentication Codes, bevor Daten verarbeitet wurden. Um Daten damit zu verarbeiten, verwenden Sie die Instanzmethode update mit Ihren Daten als Argument.

Beispiel

key = 'key'
instance = OpenSSL::HMAC.new(key, 'SHA1')
#=> f42bb0eeb018ebbd4597ae7213711ec60760843f
instance.class
#=> OpenSSL::HMAC

Ein Hinweis zu Vergleichen

Zwei Instanzen können sicher mit == in konstanter Zeit verglichen werden.

    other_instance = OpenSSL::HMAC.new('key', 'SHA1')
#=> f42bb0eeb018ebbd4597ae7213711ec60760843f
instance == other_instance
#=> true

Öffentliche Instanzmethoden

Alias für: update

== (other)

Source

# File ext/openssl/lib/openssl/hmac.rb, line 6
def ==(other)
  return false unless HMAC === other
  return false unless self.digest.bytesize == other.digest.bytesize

  OpenSSL.fixed_length_secure_compare(self.digest, other.digest)
end

Vergleicht sicher mit einer anderen HMAC-Instanz in konstanter Zeit.

base64digest → string

Source

# File ext/openssl/lib/openssl/hmac.rb, line 17
def base64digest
  [digest].pack("m0")
end

Gibt den Authentifizierungscode als Base64-kodierte Zeichenkette zurück.

digest → string

Source

static VALUE
ossl_hmac_digest(VALUE self)
{
    EVP_MD_CTX *ctx;
    size_t buf_len = EVP_MAX_MD_SIZE;
    VALUE ret;

    GetHMAC(self, ctx);
    ret = rb_str_new(NULL, EVP_MAX_MD_SIZE);
    if (EVP_DigestSignFinal(ctx, (unsigned char *)RSTRING_PTR(ret),
                            &buf_len) != 1)
        ossl_raise(eHMACError, "EVP_DigestSignFinal");
    rb_str_set_len(ret, (long)buf_len);

    return ret;
}

Gibt den Authentifizierungscode, den eine Instanz repräsentiert, als Binärzeichenkette zurück.

Beispiel

instance = OpenSSL::HMAC.new('key', 'SHA1')
#=> f42bb0eeb018ebbd4597ae7213711ec60760843f
instance.digest
#=> "\xF4+\xB0\xEE\xB0\x18\xEB\xBDE\x97\xAEr\x13q\x1E\xC6\a`\x84?"

hexdigest → string

Source

static VALUE
ossl_hmac_hexdigest(VALUE self)
{
    EVP_MD_CTX *ctx;
    unsigned char buf[EVP_MAX_MD_SIZE];
    size_t buf_len = EVP_MAX_MD_SIZE;
    VALUE ret;

    GetHMAC(self, ctx);
    if (EVP_DigestSignFinal(ctx, buf, &buf_len) != 1)
        ossl_raise(eHMACError, "EVP_DigestSignFinal");
    ret = rb_str_new(NULL, buf_len * 2);
    ossl_bin2hex(buf, RSTRING_PTR(ret), buf_len);

    return ret;
}

Gibt den Authentifizierungscode, den eine Instanz repräsentiert, als Hex-kodierte Zeichenkette zurück.

Auch aliased als: inspect, to_s

inspect

Alias für: hexdigest

reset → self

Source

static VALUE
ossl_hmac_reset(VALUE self)
{
    EVP_MD_CTX *ctx;
    EVP_PKEY *pkey;

    GetHMAC(self, ctx);
    pkey = EVP_PKEY_CTX_get0_pkey(EVP_MD_CTX_get_pkey_ctx(ctx));
    if (EVP_DigestSignInit(ctx, NULL, EVP_MD_CTX_get0_md(ctx), NULL, pkey) != 1)
        ossl_raise(eHMACError, "EVP_DigestSignInit");

    return self;
}

Gibt hmac so zurück, wie es bei der ersten Initialisierung war, wobei alle verarbeiteten Daten gelöscht sind.

Beispiel

data = "The quick brown fox jumps over the lazy dog"
instance = OpenSSL::HMAC.new('key', 'SHA1')
#=> f42bb0eeb018ebbd4597ae7213711ec60760843f

instance.update(data)
#=> de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9
instance.reset
#=> f42bb0eeb018ebbd4597ae7213711ec60760843f

to_s

Alias für: hexdigest

update(string) → self

Source

static VALUE
ossl_hmac_update(VALUE self, VALUE data)
{
    EVP_MD_CTX *ctx;

    StringValue(data);
    GetHMAC(self, ctx);
    if (EVP_DigestSignUpdate(ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1)
        ossl_raise(eHMACError, "EVP_DigestSignUpdate");

    return self;
}

Gibt hmac aktualisiert mit der zu authentifizierenden Nachricht zurück. Kann wiederholt mit Nachrichtenabschnitten aufgerufen werden.

Beispiel

first_chunk = 'The quick brown fox jumps '
second_chunk = 'over the lazy dog'

instance.update(first_chunk)
#=> 5b9a8038a65d571076d97fe783989e52278a492a
instance.update(second_chunk)
#=> de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9

Auch aliased als: <<