Padre:
OpenSSL :: Digest :: Clase

OpenSSL::Digest le permite calcular resúmenes de mensajes (a veces denominados indistintamente “hashes”) de datos arbitrarios que son criptográficamente seguros, es decir, un Digest implementa una función segura unidireccional.

Las funciones unidireccionales ofrecen algunas propiedades útiles. Por ejemplo, dadas dos entradas distintas, la probabilidad de que ambas produzcan el mismo resultado es muy poco probable. Combinado con el hecho de que cada algoritmo de resumen de mensajes tiene una salida de longitud fija de solo unos pocos bytes, los resúmenes se utilizan a menudo para crear identificadores únicos para datos arbitrarios. Un ejemplo común es la creación de una identificación única para documentos binarios que se almacenan en una base de datos.

Otra característica útil de las funciones unidireccionales (y por lo tanto el nombre) es que, dado un resumen, no hay ninguna indicación sobre los datos originales que lo produjeron, es decir, la única forma de identificar la entrada original es mediante “fuerza bruta” a través de todos los datos posibles. combinación de entradas.

Estas características hacen que las funciones unidireccionales también sean compañeros ideales para los algoritmos de firma de clave pública: en lugar de firmar un documento completo, primero se produce un hash del documento con un algoritmo de resumen de mensajes considerablemente más rápido y solo se deben firmar unos pocos bytes de su salida. utilizando el algoritmo de clave pública más lento. Para validar la integridad de un documento firmado, basta con volver a calcular el hash y verificar que sea igual al de la firma.

Puede obtener una lista de todos los algoritmos de resumen admitidos en su sistema ejecutando este comando en su terminal:

openssl list -digest-algorithms

Entre el OpenSSL 1.1.1 Los algoritmos de resumen de mensajes admitidos son:

  • SHA224, SHA256, SHA384, SHA512, SHA512-224 y SHA512-256

  • SHA3-224, SHA3-256, SHA3-384 y SHA3-512

  • BLAKE2s256 y BLAKE2b512

Cada uno de estos algoritmos se puede instanciar usando el nombre:

digest =OpenSSL::Digest.new('SHA256')

“Romper” un algoritmo de resumen de mensajes significa desafiar sus características de función unidireccional, es decir, producir una colisión o encontrar una manera de llegar a los datos originales por medios que sean más eficientes que la fuerza bruta, etc. La mayoría de los algoritmos de resumen admitidos pueden ser Considerado roto en este sentido, incluso los algoritmos MD5 y SHA1 muy populares. Si la seguridad es su principal preocupación, probablemente debería confiar en SHA224, SHA256, SHA384 o SHA512.

Hash un archivo

data =File.read('document')
sha256 =OpenSSL::Digest.new('SHA256')
digest = sha256.digest(data)

Hash de varios datos a la vez

data1 =File.read('file1')
data2 =File.read('file2')
data3 =File.read('file3')
sha256 =OpenSSL::Digest.new('SHA256')
sha256 << data1
sha256 << data2
sha256 << data3
digest = sha256.digest

Reutilizar un Digest ejemplo

data1 =File.read('file1')
sha256 =OpenSSL::Digest.new('SHA256')
digest1 = sha256.digest(data1)

data2 =File.read('file2')
sha256.reset
digest2 = sha256.digest(data2)

Métodos de clase pública

digerir(nombre, datos)Mostrar fuente

# File ext/openssl/lib/openssl/digest.rb, line 29defself.digest(name, data)super(data, name)end

Devuelve el valor hash calculado con nombreDigest. nombre es el nombre largo o el nombre corto de un algoritmo de resumen admitido.

Ejemplos de

OpenSSL::Digest.digest("SHA256","abc")

que es equivalente a:

OpenSSL::Digest.digest('SHA256',"abc")

Llama al método de superclase nuevo(string [, data]) → Resumen Mostrar fuente

static VALUE
ossl_digest_initialize(int argc, VALUE *argv, VALUE self)
    EVP_MD_CTX *ctx;const EVP_MD *md;
    VALUE type, data;rb_scan_args(argc, argv,"11",&type,&data);
    md =ossl_evp_get_digestbyname(type);if(!NIL_P(data))StringValue(data);TypedData_Get_Struct(self, EVP_MD_CTX,&ossl_digest_type, ctx);if(!ctx)RTYPEDDATA_DATA(self)= ctx =EVP_MD_CTX_new();if(!ctx)ossl_raise(eDigestError,"EVP_MD_CTX_new");if(!EVP_DigestInit_ex(ctx, md,NULL))ossl_raise(eDigestError,"Digest initialization failed");if(!NIL_P(data))returnossl_digest_update(self, data);return self;

Crea un Digest instancia basada en string, que es el ln (nombre largo) o sn (nombre corto) de un algoritmo de resumen admitido.

Si datos (a String), se utiliza como entrada inicial a la Digest ejemplo, es decir

digest =OpenSSL::Digest.new('sha256','digestdata')

es equivalente a

digest =OpenSSL::Digest.new('sha256')
digest.update('digestdata')

Métodos de instancia pública

No todos los resúmenes de mensajes se pueden calcular en una sola pasada. Si se va a calcular un resumen de mensaje a partir de varias fuentes posteriores, cada una puede pasarse individualmente al Digest ejemplo.

Ejemplo

digest =OpenSSL::Digest.new('SHA256')
digest.update('First input')
digest <<'Second input'# equivalent to digest.update('Second input')
result = digest.digest

Alias ​​para: actualización longitud_bloque → entero Mostrar fuente

static VALUE
ossl_digest_block_length(VALUE self)
    EVP_MD_CTX *ctx;GetDigest(self, ctx);returnINT2NUM(EVP_MD_CTX_block_size(ctx));

Devuelve la longitud de bloque del algoritmo de resumen, es decir, la longitud en bytes de un bloque individual. La mayoría de los algoritmos modernos dividen un mensaje para ser digerido en una secuencia de bloques de tamaño fijo que se procesan consecutivamente.

Ejemplo

digest =OpenSSL::Digest.new('SHA1')
puts digest.block_length # => 64

digest_length → entero Mostrar fuente

static VALUE
ossl_digest_size(VALUE self)
    EVP_MD_CTX *ctx;GetDigest(self, ctx);returnINT2NUM(EVP_MD_CTX_size(ctx));

Devuelve el tamaño de salida del resumen, es decir, la longitud en bytes del resultado del resumen del mensaje final.

Ejemplo

digest =OpenSSL::Digest.new('SHA1')
puts digest.digest_length # => 20

initialize_copy(p1)Mostrar fuente

static VALUE
ossl_digest_copy(VALUE self, VALUE other)
    EVP_MD_CTX *ctx1,*ctx2;rb_check_frozen(self);if(self == other)return self;TypedData_Get_Struct(self, EVP_MD_CTX,&ossl_digest_type, ctx1);if(!ctx1)RTYPEDDATA_DATA(self)= ctx1 =EVP_MD_CTX_new();if(!ctx1)ossl_raise(eDigestError,"EVP_MD_CTX_new");GetDigest(other, ctx2);if(!EVP_MD_CTX_copy(ctx1, ctx2))ossl_raise(eDigestError,NULL);return self;

nombre → string Mostrar fuente

static VALUE
ossl_digest_name(VALUE self)
    EVP_MD_CTX *ctx;GetDigest(self, ctx);returnrb_str_new2(EVP_MD_name(EVP_MD_CTX_md(ctx)));

Devuelve el sn de este Digest algoritmo.

Ejemplo

digest =OpenSSL::Digest.new('SHA512')
puts digest.name # => SHA512

reiniciar → auto Mostrar fuente

static VALUE
ossl_digest_reset(VALUE self)
    EVP_MD_CTX *ctx;GetDigest(self, ctx);if(EVP_DigestInit_ex(ctx,EVP_MD_CTX_md(ctx),NULL)!=1)ossl_raise(eDigestError,"Digest initialization failed.");return self;

Restablece el Digest en el sentido de que cualquier Digest#update que se ha realizado se abandona y el Digest vuelve a su estado inicial.

actualizar(string) → aString Mostrar fuente

VALUE
ossl_digest_update(VALUE self, VALUE data)
    EVP_MD_CTX *ctx;StringValue(data);GetDigest(self, ctx);if(!EVP_DigestUpdate(ctx,RSTRING_PTR(data),RSTRING_LEN(data)))ossl_raise(eDigestError,"EVP_DigestUpdate");return self;

No todos los resúmenes de mensajes se pueden calcular en una sola pasada. Si un resumen de mensaje se va a calcular a partir de varias fuentes posteriores, cada una puede pasarse individualmente al Digest ejemplo.

Ejemplo

digest =OpenSSL::Digest.new('SHA256')
digest.update('First input')
digest <<'Second input'# equivalent to digest.update('Second input')
result = digest.digest

También con alias: <

Métodos de instancia privada

terminar → aString Mostrar fuente

static VALUE
ossl_digest_finish(int argc, VALUE *argv, VALUE self)
    EVP_MD_CTX *ctx;
    VALUE str;int out_len;GetDigest(self, ctx);rb_scan_args(argc, argv,"01",&str);
    out_len =EVP_MD_CTX_size(ctx);if(NIL_P(str))
        str =rb_str_new(NULL, out_len);elseStringValue(str);rb_str_resize(str, out_len);if(!EVP_DigestFinal_ex(ctx,(unsignedchar*)RSTRING_PTR(str),NULL))ossl_raise(eDigestError,"EVP_DigestFinal_ex");return str;