RSASSA-PSS

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 10 de enero de 2020; las comprobaciones requieren 2 ediciones .

RSASSA-PSS ( RSA S ignature S cheme with A péndix - P robabilistic S ignature S cheme ) es un algoritmo asimétrico de firma digital . Basado en el principio de codificación PSS propuesto en 1996 por Mihir Bellare y Phillip Rogaway [1] . Introducido en el estándar PKCS # 1 v2.1 de 2002, desarrollado por RSA Laboratories , EE . UU .

Descripción del algoritmo

Que Alicia ( A ) quiera enviar un mensaje M a Bob ( B ) certificándolo con una firma electrónica S. B , habiendo recibido un mensaje de A , debe verificar la firma (comprobar la autenticidad).

En este artículo, el "byte alto (bit)" se refiere al primer byte izquierdo (bit). El "byte menos significativo (bit)" se refiere respectivamente al último byte derecho (bit).
Además, una "cadena" debe entenderse como una matriz, cuyos elementos son bytes individuales. Por lo tanto, la "representación de cadena del número n " es la cadena N obtenida al dividir la notación binaria n en bytes. Por ejemplo:

n = 258 {100000010} norte = [1|2] {00000001|00000010}

En este caso, [1] es el byte alto y [2] es el byte bajo.
Las funciones de creación y verificación de una firma electrónica se describen a continuación.

Creación de una firma

RSASSA-PSS-Signo((n, e, d), M)

Datos de entrada: (n, e, d)  - clave privada M - mensaje a firmar, cadena Producción: S  - firma, cadena de longitud k Posibles errores: "el mensaje es demasiado largo"; "error de codificación" Secuenciación:
  1. Codificación PSS: Apliquemos la función PSS-Encode (que se describirá a continuación) a la cadena M para obtener la cadena EM de longitud x . EM es tal que la longitud en bits de la representación entera de EM no supera los emBits y los zBits de los bits más significativos son 0 . EM = codificación PSS (M, emBits) Tenga en cuenta que la longitud de EM es (k-1) si emBits es divisible por 8 , e igual a k en caso contrario. Si la codificación PSS devuelve un error de "mensaje demasiado largo", se muestra un mensaje de error y se detiene el trabajo. Si la codificación PSS devuelve un error de "error de codificación", se muestra un mensaje de error y se detiene el trabajo.
  2. Firma RSA:
    • Asigne m una representación entera de la cadena EM .
    m = str-to-int(EM) s = metro re mod norte
    • Representemos s como una cadena de bytes de longitud k .
    S = int-to-str(s, k)
  3. Salida S
Codificación PSS

Codificación PSS (M, emBits)

Opciones: Función hash  - hash , devuelve una cadena de bytes de longitud hLen MGF  - función de generación de máscaras. Convierte una cadena de bytes de entrada en una cadena de la longitud dada (descrito en detalle a continuación). sLen  es la longitud de la cadena de bytes salt Datos de entrada: M  - mensaje a firmar, cadena emBits  es la longitud máxima en bits de la representación entera de la cadena de salida EM , al menos (8hLen + 8sLen + 9) Producción: EM  : mensaje codificado, cadena de longitud emLen Posibles errores: "el mensaje es demasiado largo"; "error de codificación" Secuenciación:
  1. Si la longitud de M es mayor que la longitud máxima posible de la cadena de entrada de la función hash seleccionada ( byte para SHA-1 ), se devuelve el mensaje "mensaje demasiado largo" y se finaliza la operación.
  2. mHash = Hash(M), cadena de longitud hLen .
  3. Si emLen < (hLen + sLen + 2), se devuelve un mensaje de "error de codificación" y se detiene el trabajo.
  4. Se genera una sal de cadena aleatoria de longitud sLen ; si sLen = 0 , salt  es una cadena vacía .
  5. M' = (0x)00 00 00 00 00 00 00 00||mHash||salt , una cadena de longitud (8 + hLen + sLen), cuyos primeros 8 bytes son cero.
  6. H = Hash(M') , cadena de longitud hLen .
  7. Se genera una cadena PS que consta de (emLen - hLen - sLen - 2) bytes nulos. La longitud de PS puede ser cero.
  8. DB = PS||0x01||salt , cadena de longitud (emLen - hLen - 1) .
  9. dbMask = MGF(H, emLen - hLen - 1) , cadena de longitud (emLen - hLen - 1) .
  10. enmascaradoDB = DB ⊕ dbMask .
  11. Los zBits de los bits altos en el byte alto de maskedDB se establecen en 0 .
  12. TF=0xBC .
  13. EM = enmascaradoDB||H||TF
  14. Salida EM .

Verificación de firma

RSASSA-PSS-Verificar ((n, e), M, S)

Datos de entrada: (n, e)  - clave pública M  - mensaje recibido, cadena S  es la firma a verificar, una cadena de longitud k Producción: "la firma es válida" o "la firma no es válida" Secuenciación:
  1. Comprobación de longitud: Si la longitud de la firma S es más de k bytes, entonces se toma la decisión "la firma no es válida" y el trabajo finaliza.
  2. Comprobación RSA:
    • Asigne m una representación entera de la cadena S .
    m = str-to-int(S)
    • Utilizamos la clave pública.
    s = yo mod n
    • Representemos m como una cadena de bytes de longitud emLen.
    EM = int-to-str(m, emLen) Tenga en cuenta que emLen es (k-1) si emBits es divisible por 8 e igual a k en caso contrario. Si el registro del número m ocupa más de emLen bytes, se toma la decisión "la firma no es válida" y el trabajo se detiene.
  3. Control PSS: Usemos la función PSS-Verify (que se describirá a continuación). La decisión final es la misma que tomó PSS-Verify . Salida = PSS-Verificar (M, EM, emBits)
Comprobación de PSS

Verificación de PSS (M, EM, emBits)

Opciones: Hash  es una función hash que devuelve una cadena de bytes de longitud hLen. MGF  - función de generación de máscaras. Convierte una cadena de bytes de entrada en una cadena de la longitud dada (descrito en detalle a continuación). sLen  es la longitud de la cadena de bytes salt. Datos de entrada: M  : mensaje recibido, cadena. EM  - mensaje codificado, cadena de longitud emLen . emBits  es la longitud máxima en bits de una representación entera de una cadena EM, al menos (8hLen + 8sLen + 9) . Producción: "la firma es válida" o "la firma no es válida" Secuenciación:
  1. Si la longitud M es mayor que la longitud máxima posible de la cadena de entrada de la función hash seleccionada ( bytes para SHA-1), se toma una decisión de "firma no válida" y se detiene el trabajo.
  2. mHash = Hash(M) , una cadena de longitud hLen .
  3. Si emLen < (hLen + sLen + 2) , se toma una decisión de "firma no válida" y se detiene el trabajo.
  4. Si el byte bajo EM (campo TF ) no es igual a 0xBC , entonces se toma la decisión "la firma no es válida" y el trabajo se detiene.
  5. Los bytes EM más altos ( emLen - hLen - 1) se escriben en la cadena maskedDB y los bytes hLen subsiguientes se escriben en la cadena H.
  6. Si los bits de zBits altos del byte alto de maskedDB no son cero, entonces se toma una decisión de "firma no válida" y se termina el trabajo.
  7. dbMask = MGF(H, emLen - hLen - 1) , cadena de longitud (emLen - hLen - 1) .
  8. DB = maskedDB ⊕ dbMask .
  9. Los zBits de los bits altos en el byte alto de la base de datos se establecen en 0 .
  10. Si los bytes más altos ( emLen - hLen - sLen - 2) de la base de datos no son iguales a 0 o si el byte posterior (el byte en la posición (emLen - hLen - sLen - 1) , suponiendo que la posición del byte alto es 1 ) no es igual a 0x01 , luego se toma una decisión "la firma no es válida" y el trabajo se detiene.
  11. Los últimos bytes sLen de la base de datos se escriben en la cadena de bytes salt.
  12. M' = (0x)00 00 00 00 00 00 00 00||mHash||salt , una cadena de longitud (8 + hLen + sLen) , cuyos primeros 8 bytes son cero.
  13. H' = Hash(M') , una cadena de longitud hLen.
  14. Si H = H' , entonces se toma la decisión "la firma es válida", de lo contrario, se toma la decisión "la firma no es válida".

Función de generación de máscaras

Describamos el MGF utilizado en las funciones PSS.
El MGF acepta una cadena de bytes de longitud arbitraria y una longitud deseada de la cadena de salida como entrada y produce una cadena de bytes de la longitud deseada. Se pueden imponer limitaciones a las longitudes de las cadenas de entrada y salida, pero normalmente son muy grandes. MGF es determinista; la cadena de salida está completamente determinada por la cadena de entrada. La salida del MGF debería ser pseudoaleatoria, es decir, conociendo parte de la cadena de salida, debería ser prácticamente imposible predecir el resto de la cadena de salida. Esto se puede lograr haciendo que el MGF se base en una función hash con la misma propiedad. Esta propiedad es necesaria, ya que en ella se basa la prueba de la fiabilidad del algoritmo.
El estándar PKCS#1 v2.1 propone utilizar la siguiente función como MGF:

MGF1(M,maskLen)

Opciones: Hash  es una función hash que devuelve una cadena de bytes de longitud hLen. Datos de entrada: M  es la cadena a convertir. maskLen  es la longitud requerida de la cadena de bytes de salida, no excede 2 32 hLen . Producción: mask  es una cadena de longitud maskLen. Posibles errores: "La máscara es demasiado larga" Secuenciación:
  1. Si maskLen > 2 32 hLen , se muestra el mensaje "La longitud de la máscara es demasiado grande" y la operación se detiene.
  2. Sea T  una cadena vacía.
  3. EN el bucle FOR i FROM 0 TO SE REALIZA:
    • Representemos i como una cadena de bytes C de 4 bytes de longitud .
    C = int-a-str(i,4)
    • M' = M||C .
    • Agreguemos el resultado hash M' al final de la cadena T.
    T = T||Hash(M')
  4. Escribamos los bytes superiores de maskLen de la cadena T en mask .
  5. La salida de la máscara .

Opciones

En el estándar PKCS#1 v2.1 , RSASSA-PSS recibe el identificador id-RSASSA-PSS , al que se debe asociar una secuencia de cuatro parámetros. Estos parámetros incluyen la función hash, MGF, la longitud de la cadena salt generada aleatoriamente ( sLen ), trailerField ( campo TF ). Los valores predeterminados de estos parámetros, dados en el estándar en cuestión, se dan en la tabla.

Parámetro Tipo de Valor por defecto
algoritmo hash Algoritmo hash sha1
máscaraGenAlgoritmo MáscaraGenAlgoritmo mgf1SHA1
salLongitud ENTERO veinte
campo de remolque RemolqueCampo trailerFieldBC
  • Se recomienda que la función hash en la que se basa el MGF (si existe) sea la misma que la especificada por el parámetro hashAlgorithm .
  • El valor predeterminado del parámetro saltLength es igual a la longitud de la cadena de salida de la función hash seleccionada ( hLen ). A diferencia de las otras opciones, no es necesario corregir saltLength para un par de claves RSA determinado.
  • El campo TF se introduce por compatibilidad con el borrador P1363a de IEEE . En el estándar considerado, solo se admite un valor de trailerField igual a 0xBC . Sin embargo, también puede tomar otra forma, como HID||0xCC , donde HID  es un identificador de función hash especificado en el estándar ISO/IEC 10118.

Características

La longitud de mensaje permitida para el método RSA-PSS es ilimitada o está limitada a un valor muy grande debido a la función hash utilizada en la codificación de PSS.

RSA-PSS se diferencia de otros esquemas de firma digital basados ​​en RSA en que es probabilístico en lugar de determinista. implica el uso de un valor generado aleatoriamente ( salt ). El valor de la sal mejora la fiabilidad del circuito [1] .

Confiabilidad

Suponiendo que calcular un módulo n raíz arbitrario es una operación impracticable y que la función hash y MGF tienen las propiedades necesarias, RSA-PSS garantiza la seguridad de la firma. La robustez es comprobable en el sentido de que la dificultad de descifrar una firma puede estar directamente relacionada con la dificultad de descifrar una primitiva criptográfica (el problema matemático subyacente a RSA ). La probabilidad de craqueo exitoso y el tiempo de ejecución del mejor método de craqueo RSA-PSS están muy cerca de los mismos parámetros del algoritmo para encontrar la función inversa de RSA .

El esquema de firma descrito anteriormente difiere del algoritmo original propuesto por Mihir Bellare y Phillip Rogaway [1] . Sin embargo, la prueba necesaria para este esquema la proporciona Jacob Jonsson [2] .

Notas

  1. ↑ 1 2 3 Mihir Bellare, Phillip Rogaway "La seguridad exacta de las firmas digitales: cómo firmar con RSA y Rabin" . Consultado el 1 de noviembre de 2010. Archivado desde el original el 13 de junio de 2010.
  2. ↑ Jacob Jonsson "Pruebas de seguridad para el esquema de firma RSA-PSS y sus variantes" (PDF) . Consultado el 1 de noviembre de 2010. Archivado desde el original el 6 de marzo de 2016.

Fuentes

 Criptosistemas de clave pública
Algoritmos
Factorización de números enteros
logaritmo discreto
Criptografía en celosías
Otro
Teoría
Estándares
Temas