RFC 8017 - PKCS #1 : Spécifications de cryptographie RSA version 2.2

Statut: Informational
Publié: November 2016
Stream: IETF
Remplace: RFC3447
Errata: Pas d'errata

Résumé (Abstract)

Ce document fournit des recommandations pour l'implémentation de la cryptographie à clé publique basée sur l'algorithme RSA, couvrant les primitives cryptographiques, les schémas de chiffrement, les schémas de signature avec annexe et la syntaxe ASN.1 pour représenter les clés et identifier les schémas.

Ce document représente une republication de PKCS #1 v2.2 de la série des standards de cryptographie à clé publique (PKCS) de RSA Laboratories. Par cette publication RFC, le contrôle des modifications est transféré à l'IETF.

Ce document rend également obsolète le RFC 3447.

Statut de ce mémo

Ce document n'est pas une spécification de piste de standards Internet ; il est publié à des fins d'information.

Ce document est un produit de l'Internet Engineering Task Force (IETF). Il représente le consensus de la communauté IETF. Il a reçu un examen public et a été approuvé pour publication par l'Internet Engineering Steering Group (IESG). Tous les documents approuvés par l'IESG ne sont pas candidats à un quelconque niveau de standard Internet ; voir la Section 2 du RFC 7841.

Des informations sur le statut actuel de ce document, toute errata et comment fournir des commentaires peuvent être obtenues à http://www.rfc-editor.org/info/rfc8017.

Table des matières

1. Introduction
- 1.1 Langage des exigences
2. Notation
3. Types de clés
- 3.1 Clé publique RSA
- 3.2 Clé privée RSA
4. Primitives de conversion de données
- 4.1 I2OSP
- 4.2 OS2IP
5. Primitives cryptographiques
- 5.1 Primitives de chiffrement et de déchiffrement
- 5.2 Primitives de signature et de vérification
6. Vue d'ensemble des schémas
7. Schémas de chiffrement
- 7.1 RSAES-OAEP
- 7.2 RSAES-PKCS1-v1_5
8. Schéma de signature avec annexe
- 8.1 RSASSA-PSS
- 8.2 RSASSA-PKCS1-v1_5
9. Méthodes d'encodage pour les signatures avec annexe
- 9.1 EMSA-PSS
- 9.2 EMSA-PKCS1-v1_5
10. Considérations de sécurité
11. Références
- 11.1 Références normatives
- 11.2 Références informatives

Annexes

Annexe A. Syntaxe ASN.1
- A.1 Représentation des clés RSA
- A.2 Identification des schémas
Annexe B. Techniques de support
- B.1 Fonctions de hachage
- B.2 Fonctions de génération de masque
Annexe C. Module ASN.1
Annexe D. Historique des révisions de PKCS #1
Annexe E. À propos de PKCS

Ressources connexes

Texte officiel : RFC 8017
Page officielle : RFC 8017 DataTracker
Errata : RFC Editor Errata
Document rendu obsolète : RFC 3447 (PKCS #1 v2.1)

1. Introduction

Ce document fournit des recommandations pour l'implémentation de la cryptographie à clé publique (Public-Key Cryptography) basée sur l'algorithme RSA [RSA], couvrant les aspects suivants :

Primitives cryptographiques (Cryptographic Primitives)
Schémas de chiffrement (Encryption Schemes)
Schémas de signature avec annexe (Signature Schemes with Appendix)
Syntaxe ASN.1 pour représenter les clés et identifier les schémas

Ces recommandations sont destinées à une application générale dans les systèmes informatiques et de communication et incluent donc une grande flexibilité. Il est attendu que les standards d'application basés sur ces spécifications puissent inclure des contraintes supplémentaires. Ces recommandations sont destinées à être compatibles avec les standards IEEE 1363 [IEEE1363], IEEE 1363a [IEEE1363A] et ANSI X9.44 [ANSIX944].

Ce document remplace PKCS #1 version 2.1 [RFC3447] mais inclut des techniques compatibles.

L'organisation de ce document est la suivante :

La section 1 est une introduction.
La section 2 définit certaines notations utilisées dans ce document.
La section 3 définit les types de clés publiques et privées RSA.
Les sections 4 et 5 définissent plusieurs primitives (Primitives), ou opérations mathématiques de base. Les primitives de conversion de données sont dans la section 4, et les primitives cryptographiques (chiffrement-déchiffrement et signature-vérification) sont dans la section 5.
Les sections 6, 7 et 8 traitent des schémas de chiffrement et de signature dans ce document. La section 6 donne un aperçu. En plus des méthodes trouvées dans PKCS #1 v1.5, la section 7 définit un schéma de chiffrement basé sur le remplissage optimal de chiffrement asymétrique (Optimal Asymmetric Encryption Padding, OAEP) [OAEP], et la section 8 définit un schéma de signature avec annexe basé sur le schéma de signature probabiliste (Probabilistic Signature Scheme, PSS) [RSARABIN] [PSS].
La section 9 définit les méthodes d'encodage pour les schémas de signature de la section 8.
L'annexe A définit la syntaxe ASN.1 pour les clés définies dans la section 3 et les schémas des sections 7 et 8.
L'annexe B définit les fonctions de hachage (Hash Functions) et la fonction de génération de masque (Mask Generation Function, MGF) utilisées dans ce document, y compris la syntaxe ASN.1 pour ces techniques.
L'annexe C fournit un module ASN.1.
Les annexes D et E décrivent l'historique des révisions de PKCS #1 et fournissent des informations générales sur les standards de cryptographie à clé publique (Public-Key Cryptography Standards).

Ce document représente une republication de PKCS #1 v2.2 [PKCS1_22] de la série des standards de cryptographie à clé publique (PKCS) de RSA Laboratories.

1.1. Langage des exigences (Requirements Language)

Les mots-clés « MUST » (doit), « MUST NOT » (ne doit pas), « REQUIRED » (requis), « SHALL » (doit), « SHALL NOT » (ne doit pas), « SHOULD » (devrait), « SHOULD NOT » (ne devrait pas), « RECOMMENDED » (recommandé), « MAY » (peut) et « OPTIONAL » (optionnel) dans ce document doivent être interprétés comme décrit dans [RFC2119].

2. Notation

La notation dans ce document inclut :

Symbole	Description
c	représentant du texte chiffré (Ciphertext Representative), un entier entre 0 et n-1
C	texte chiffré (Ciphertext), une chaîne d'octets (Octet String)
d	exposant privé RSA (RSA Private Exponent)
d_i	exposant CRT du facteur additionnel r_i (Additional Factor r_i's CRT Exponent), un entier positif tel que e * d_i == 1 (mod (r_i-1)), i = 3, ..., u
dP	exposant CRT de p, un entier positif tel que e * dP == 1 (mod (p-1))
dQ	exposant CRT de q, un entier positif tel que e * dQ == 1 (mod (q-1))
e	exposant public RSA (RSA Public Exponent)
EM	message encodé (Encoded Message), une chaîne d'octets
emBits	longueur (prévue) en bits d'un message encodé EM
emLen	longueur (prévue) en octets d'un message encodé EM
GCD(. , .)	plus grand commun diviseur de deux entiers non négatifs (Greatest Common Divisor)
Hash	fonction de hachage (Hash Function)
hLen	longueur de sortie en octets de la fonction de hachage Hash
k	longueur en octets du module RSA n
K	clé privée RSA (RSA Private Key)
L	étiquette RSAES-OAEP optionnelle (Label), une chaîne d'octets
LCM(., ..., .)	plus petit commun multiple d'une liste d'entiers non négatifs (Least Common Multiple)
m	représentant du message (Message Representative), un entier entre 0 et n-1
M	message (Message), une chaîne d'octets
mask	sortie MGF, une chaîne d'octets
maskLen	longueur (prévue) de la chaîne d'octets mask
MGF	fonction de génération de masque (Mask Generation Function)
mgfSeed	graine à partir de laquelle le masque est généré (Seed), une chaîne d'octets
mLen	longueur en octets d'un message M
n	module RSA (RSA Modulus), n = r_1 * r_2 * ... * r_u, u >= 2
(n, e)	clé publique RSA (RSA Public Key)
p, q	deux premiers facteurs premiers du module RSA n (Prime Factors)
qInv	coefficient CRT (CRT Coefficient), un entier positif inférieur à p tel que q * qInv == 1 (mod p)
r_i	facteurs premiers du module RSA n, incluant r_1 = p, r_2 = q et des facteurs additionnels s'il y en a
s	représentant de signature (Signature Representative), un entier entre 0 et n-1
S	signature (Signature), une chaîne d'octets
sLen	longueur en octets du sel EMSA-PSS (Salt)
t_i	coefficient CRT du facteur premier additionnel r_i, un entier positif inférieur à r_i tel que r_1 * r_2 * ... * r_(i-1) * t_i == 1 (mod r_i), i = 3, ..., u
u	nombre de facteurs premiers du module RSA, u >= 2
x	un entier non négatif
X	une chaîne d'octets correspondant à x
xLen	longueur (prévue) de la chaîne d'octets X
0x	indicateur de représentation hexadécimale d'un octet ou d'une chaîne d'octets : « 0x48 » désigne l'octet de valeur hexadécimale 48 ; « (0x)48 09 0e » désigne la chaîne de trois octets consécutifs de valeurs hexadécimales 48, 09 et 0e, respectivement
λ(n)	LCM(r_1-1, r_2-1, ..., r_u-1)
⊕	ou exclusif bit à bit de deux chaînes d'octets (Bit-wise Exclusive-OR)
⌈.⌉	fonction plafond (Ceiling Function) ; ⌈x⌉ est le plus petit entier supérieur ou égal au nombre réel x
\|\|	opérateur de concaténation (Concatenation Operator)
==	symbole de congruence (Congruence Symbol) ; a == b (mod n) signifie que l'entier n divise l'entier a - b

Note : Le théorème des restes chinois (Chinese Remainder Theorem, CRT) peut être appliqué de manière non récursive ainsi que récursive. Dans ce document, une approche récursive suivant l'algorithme de Garner [GARNER] est utilisée. Voir également la note 1 dans la section 3.2.

3. Types de clés (Key Types)

Deux types de clés sont employés dans les primitives et les schémas définis dans ce document : clé publique RSA (RSA Public Key) et clé privée RSA (RSA Private Key). Ensemble, une clé publique RSA et une clé privée RSA forment une paire de clés RSA (RSA Key Pair).

Cette spécification prend en charge ce qu'on appelle le RSA « multi-premier » (Multi-prime), où le module peut avoir plus de deux facteurs premiers. L'avantage du RSA multi-premier est un coût de calcul inférieur pour les primitives de déchiffrement et de signature, à condition que le théorème des restes chinois (Chinese Remainder Theorem, CRT) soit utilisé. De meilleures performances peuvent être obtenues sur les plateformes monoprocesseur, mais dans une plus large mesure sur les plateformes multiprocesseur, où les exponentiations modulaires impliquées peuvent être effectuées en parallèle.

Pour une discussion sur la façon dont le multi-premier affecte la sécurité du cryptosystème RSA, le lecteur est renvoyé à [SILVERMAN].

3.1. Clé publique RSA (RSA Public Key)

Aux fins de ce document, une clé publique RSA se compose de deux composants :

n        module RSA (RSA Modulus), un entier positif
e        exposant public RSA (RSA Public Exponent), un entier positif

Dans une clé publique RSA valide, le module RSA n est un produit de u nombres premiers impairs distincts r_i, i = 1, 2, ..., u, où u >= 2, et l'exposant public RSA e est un entier entre 3 et n - 1 satisfaisant GCD(e, λ(n)) = 1, où λ(n) = LCM(r_1 - 1, ..., r_u - 1). Par convention, les deux premiers nombres premiers r_1 et r_2 peuvent également être désignés respectivement par p et q.

Une syntaxe recommandée pour l'échange de clés publiques RSA entre implémentations est donnée dans l'annexe A.1.1 ; la représentation interne d'une implémentation peut différer.

3.2. Clé privée RSA (RSA Private Key)

Aux fins de ce document, une clé privée RSA peut avoir l'une des deux représentations.

Représentation 1

La première représentation consiste en la paire (n, d), où les composants ont les significations suivantes :

n       module RSA (RSA Modulus), un entier positif
d       exposant privé RSA (RSA Private Exponent), un entier positif

Représentation 2

La deuxième représentation consiste en un quintuplet (p, q, dP, dQ, qInv) et une séquence (éventuellement vide) de triplets (r_i, d_i, t_i), i = 3, ..., u, un pour chaque nombre premier non présent dans le quintuplet, où les composants ont les significations suivantes :

p      le premier facteur, un entier positif
q      le deuxième facteur, un entier positif
dP     l'exposant CRT du premier facteur, un entier positif
dQ     l'exposant CRT du deuxième facteur, un entier positif
qInv   le (premier) coefficient CRT, un entier positif
r_i    le i-ème facteur, un entier positif
d_i    l'exposant CRT du i-ème facteur, un entier positif
t_i    le coefficient CRT du i-ème facteur, un entier positif

Contraintes de validité

Dans une clé privée RSA valide avec la première représentation, le module RSA n est le même que dans la clé publique RSA correspondante et est le produit de u nombres premiers impairs distincts r_i, i = 1, 2, ..., u, où u >= 2. L'exposant privé RSA d est un entier positif inférieur à n satisfaisant :

e * d == 1 (mod λ(n))

où e est l'exposant public RSA correspondant et λ(n) est défini comme dans la section 3.1.

Dans une clé privée RSA valide avec la deuxième représentation, les deux facteurs p et q sont les deux premiers facteurs premiers du module RSA n (c'est-à-dire, r_1 et r_2) ; les exposants CRT dP et dQ sont des entiers positifs inférieurs à p et q, respectivement, satisfaisant :

e * dP == 1 (mod (p-1))
e * dQ == 1 (mod (q-1))

et le coefficient CRT qInv est un entier positif inférieur à p satisfaisant :

q * qInv == 1 (mod p)

Si u > 2, la représentation incluera un ou plusieurs triplets (r_i, d_i, t_i), i = 3, ..., u. Les facteurs r_i sont les facteurs premiers supplémentaires du module RSA n. Chaque exposant CRT d_i (i = 3, ..., u) satisfait :

e * d_i == 1 (mod (r_i - 1))

Chaque coefficient CRT t_i (i = 3, ..., u) est un entier positif inférieur à r_i satisfaisant :

R_i * t_i == 1 (mod r_i)

où R_i = r_1 * r_2 * ... * r_(i-1).

Une syntaxe recommandée pour l'échange de clés privées RSA entre implémentations, qui inclut des composants des deux représentations, est donnée dans l'annexe A.1.2 ; la représentation interne d'une implémentation peut différer.

Notes

Note 1 : La définition des coefficients CRT ici et les formules qui les utilisent dans les primitives de la section 5 suivent généralement l'algorithme de Garner [GARNER] (voir aussi l'algorithme 14.71 dans [HANDBOOK]). Cependant, pour la compatibilité avec les représentations des clés privées RSA dans PKCS #1 v2.0 et les versions précédentes, les rôles de p et q sont inversés par rapport au reste des nombres premiers. Ainsi, le premier coefficient CRT, qInv, est défini comme l'inverse de q mod p, plutôt que comme l'inverse de R_1 mod r_2, c'est-à-dire, de p mod q.

Note 2 : Quisquater et Couvreur [FASTDEC] ont observé l'avantage d'appliquer le CRT aux opérations RSA.

4. Primitives de conversion de données (Data Conversion Primitives)

Deux primitives de conversion de données (Data Conversion Primitives) sont utilisées dans les schémas définis dans ce document :

I2OSP - Primitive de conversion entier vers chaîne d'octets (Integer-to-Octet-String Primitive)
OS2IP - Primitive de conversion chaîne d'octets vers entier (Octet-String-to-Integer Primitive)

Aux fins de ce document, et en cohérence avec la syntaxe ASN.1, une chaîne d'octets (Octet String) est une séquence ordonnée d'octets (octets de 8 bits). Cette séquence est indexée du premier (par convention, le plus à gauche) au dernier (le plus à droite). Pour les conversions avec des entiers, dans les primitives de conversion suivantes, le premier octet est considéré comme le plus significatif.

4.1. I2OSP

I2OSP convertit un entier non négatif en une chaîne d'octets de longueur spécifiée.

I2OSP (x, xLen)

Entrée (Input)

x        entier non négatif à convertir
xLen     longueur prévue de la chaîne d'octets résultante

Sortie (Output)

X        chaîne d'octets correspondante de longueur xLen

Erreur (Error)

"integer too large" (entier trop grand)

Étapes (Steps)

Étape 1. Si x >= 256^xLen, sortir "integer too large" et arrêter.

Étape 2. Écrire l'entier x dans sa représentation unique en base 256 à xLen chiffres :

x = x_(xLen-1) * 256^(xLen-1) + x_(xLen-2) * 256^(xLen-2) + ... + x_1 * 256 + x_0

où 0 <= x_i < 256 (notez que si x est inférieur à 256^(xLen-1), un ou plusieurs chiffres de tête seront nuls).

Étape 3. Soit la valeur entière de l'octet X_i égale à x_(xLen-i), où 1 <= i <= xLen. Sortir la chaîne d'octets :

X = X_1 X_2 ... X_xLen

4.2. OS2IP

OS2IP convertit une chaîne d'octets en un entier non négatif.

OS2IP (X)

Entrée (Input)

X        chaîne d'octets à convertir

Sortie (Output)

x        entier non négatif correspondant

Étapes (Steps)

Étape 1. Soit X_1 X_2 ... X_xLen les octets de X du premier au dernier, et soit x_(xLen-i) la valeur entière de l'octet X_i, où 1 <= i <= xLen.

Étape 2. Soit :

x = x_(xLen-1) * 256^(xLen-1) + x_(xLen-2) * 256^(xLen-2) + ... + x_1 * 256 + x_0

Étape 3. Sortir x.

5. Primitives cryptographiques (Cryptographic Primitives)

Les primitives cryptographiques (Cryptographic Primitives) sont des opérations mathématiques de base à partir desquelles des schémas cryptographiques peuvent être construits. Elles sont destinées à être utilisées dans des implémentations matérielles ou comme modules logiciels, et ne sont pas destinées à fournir de la sécurité indépendamment des schémas.

Ce document spécifie quatre types de primitives, organisées par paires : chiffrement et déchiffrement (Encryption and Decryption); signature et vérification (Signature and Verification).

La spécification des primitives suppose que les entrées satisfont certaines conditions, en particulier que les clés publiques et privées RSA sont valides.

5.1. Primitives de chiffrement et de déchiffrement (Encryption and Decryption Primitives)

Une primitive de chiffrement (Encryption Primitive) produit un représentant de texte chiffré à partir d'un représentant de message sous le contrôle d'une clé publique, et une primitive de déchiffrement (Decryption Primitive) récupère un représentant de message à partir d'un représentant de texte chiffré sous le contrôle de la clé privée correspondante.

Une paire de primitives de chiffrement et de déchiffrement est utilisée dans les schémas de chiffrement définis dans ce document et est spécifiée ici : primitive de chiffrement RSA (RSAEP, RSA Encryption Primitive) / primitive de déchiffrement RSA (RSADP, RSA Decryption Primitive). RSAEP et RSADP impliquent la même opération mathématique, avec différentes clés en entrée. Les primitives définies ici sont les mêmes que la primitive de chiffrement par factorisation d'entiers utilisant RSA (IFEP-RSA) / primitive de déchiffrement par factorisation d'entiers utilisant RSA (IFDP-RSA) dans IEEE 1363 [IEEE1363] (à l'exception de l'ajout du support pour le RSA multi-premier), et sont compatibles avec PKCS #1 v1.5.

L'opération mathématique principale dans chaque primitive est l'exponentiation (Exponentiation).

5.1.1. RSAEP

RSAEP ((n, e), m)

Entrée (Input)

(n, e)   clé publique RSA
m        représentant du message, un entier entre 0 et n - 1

Sortie (Output)

c        représentant du texte chiffré, un entier entre 0 et n - 1

Erreur (Error)

"message representative out of range" (représentant du message hors plage)

Hypothèse (Assumption)

La clé publique RSA (n, e) est valide

Étapes (Steps)

Étape 1. Si le représentant du message m n'est pas entre 0 et n - 1, sortir "message representative out of range" et arrêter.

Étape 2. Soit c = m^e mod n.

Étape 3. Sortir c.

5.1.2. RSADP

RSADP (K, c)

Entrée (Input)

K        clé privée RSA, où K a l'une des formes suivantes :
         - paire (n, d)
         - quintuplet (p, q, dP, dQ, qInv) et séquence éventuellement vide de triplets (r_i, d_i, t_i), i = 3, ..., u
c        représentant du texte chiffré, un entier entre 0 et n - 1

Sortie (Output)

m        représentant du message, un entier entre 0 et n - 1

Erreur (Error)

"ciphertext representative out of range" (représentant du texte chiffré hors plage)

Hypothèse (Assumption)

La clé privée RSA K est valide

Étapes (Steps)

Étape 1. Si le représentant du texte chiffré c n'est pas entre 0 et n - 1, sortir "ciphertext representative out of range" et arrêter.

Étape 2. Le représentant du message m est calculé comme suit :

a. Si la première forme de K (n, d) est utilisée, soit m = c^d mod n.

b. Si la deuxième forme de K (p, q, dP, dQ, qInv) et (r_i, d_i, t_i) est utilisée, procéder comme suit :

i. Soit m_1 = c^dP mod p et m_2 = c^dQ mod q.

ii. Si u > 2, soit m_i = c^(d_i) mod r_i, i = 3, ..., u.

iii. Soit h = (m_1 - m_2) * qInv mod p.

iv. Soit m = m_2 + q * h.

v. Si u > 2, soit R = r_1 et pour i = 3 à u, exécuter :

Soit R = R * r_(i-1).
Soit h = (m_i - m) * t_i mod r_i.
Soit m = m + R * h.

Étape 3. Sortir m.

Note : L'étape 2.b peut être réécrite comme une seule boucle, à condition que l'ordre de p et q soit inversé. Cependant, pour la cohérence avec PKCS #1 v2.0, les deux premiers nombres premiers p et q sont traités séparément des nombres premiers supplémentaires.

5.2. Primitives de signature et de vérification (Signature and Verification Primitives)

Une primitive de signature (Signature Primitive) produit un représentant de signature à partir d'un représentant de message sous le contrôle d'une clé privée, et une primitive de vérification (Verification Primitive) récupère un représentant de message à partir d'un représentant de signature sous le contrôle de la clé publique correspondante. Une paire de primitives de signature et de vérification est utilisée dans les schémas de signature définis dans ce document et est spécifiée ici : primitive de signature RSA version 1 (RSASP1, RSA Signature Primitive, version 1) / primitive de vérification RSA version 1 (RSAVP1, RSA Verification Primitive, version 1).

Les primitives définies ici sont les mêmes que la primitive de signature par factorisation d'entiers utilisant RSA version 1 (IFSP-RSA1) / primitive de vérification par factorisation d'entiers utilisant RSA version 1 (IFVP-RSA1) dans IEEE 1363 [IEEE1363] (à l'exception de l'ajout du support pour le RSA multi-premier), et sont compatibles avec PKCS #1 v1.5.

L'opération mathématique principale dans chaque primitive est l'exponentiation, comme dans les primitives de chiffrement et de déchiffrement de la section 5.1. RSASP1 et RSAVP1 sont identiques à RSADP et RSAEP, sauf pour les noms des paramètres d'entrée et de sortie ; ils sont distingués car ils sont utilisés à des fins différentes.

5.2.1. RSASP1

RSASP1 (K, m)

Entrée (Input)

K        clé privée RSA, où K a l'une des formes suivantes :
         - paire (n, d)
         - quintuplet (p, q, dP, dQ, qInv) et séquence éventuellement vide de triplets (r_i, d_i, t_i), i = 3, ..., u
m        représentant du message, un entier entre 0 et n - 1

Sortie (Output)

s        représentant de signature, un entier entre 0 et n - 1

Erreur (Error)

"message representative out of range" (représentant du message hors plage)

Hypothèse (Assumption)

La clé privée RSA K est valide

Étapes (Steps)

Étape 1. Si le représentant du message m n'est pas entre 0 et n - 1, sortir "message representative out of range" et arrêter.

Étape 2. Le représentant de signature s est calculé comme suit :

a. Si la première forme de K (n, d) est utilisée, soit s = m^d mod n.

b. Si la deuxième forme de K (p, q, dP, dQ, qInv) et (r_i, d_i, t_i) est utilisée, procéder comme suit :

Soit s_1 = m^dP mod p et s_2 = m^dQ mod q.
Si u > 2, soit s_i = m^(d_i) mod r_i, i = 3, ..., u.
Soit h = (s_1 - s_2) * qInv mod p.
Soit s = s_2 + q * h.
Si u > 2, soit R = r_1 et pour i = 3 à u, exécuter :
- a. Soit R = R * r_(i-1).
- b. Soit h = (s_i - s) * t_i mod r_i.
- c. Soit s = s + R * h.

Étape 3. Sortir s.

5.2.2. RSAVP1

RSAVP1 ((n, e), s)

Entrée (Input)

(n, e)   clé publique RSA
s        représentant de signature, un entier entre 0 et n - 1

Sortie (Output)

m        représentant du message, un entier entre 0 et n - 1

Erreur (Error)

"signature representative out of range" (représentant de signature hors plage)

Hypothèse (Assumption)

La clé publique RSA (n, e) est valide

Étapes (Steps)

Étape 1. Si le représentant de signature s n'est pas entre 0 et n - 1, sortir "signature representative out of range" et arrêter.

Étape 2. Soit m = s^e mod n.

Étape 3. Sortir m.

6. Vue d'ensemble des schémas (Overview of Schemes)

Un schéma (Scheme) combine des primitives cryptographiques et d'autres techniques pour atteindre un objectif de sécurité particulier. Ce document spécifie deux types de schémas : les schémas de chiffrement (Encryption Schemes) et les schémas de signature avec appendice (Signature Schemes with Appendix).

Les schémas spécifiés dans ce document ont une portée limitée, car leurs opérations ne comprennent que les étapes de traitement des données à l'aide d'une clé publique ou privée RSA, et n'incluent pas les étapes d'obtention ou de vérification des clés. Par conséquent, en plus des opérations de schéma, les applications incluront généralement des opérations de gestion des clés (Key Management Operations) par lesquelles les parties peuvent sélectionner les clés publiques et privées RSA pour les opérations de schéma. Les opérations supplémentaires spécifiques et d'autres détails sont en dehors de la portée de ce document.

Comme c'est le cas pour les primitives cryptographiques (Section 5), la spécification des opérations de schéma suppose que les entrées satisfont certaines conditions, en particulier que les clés publiques et privées RSA sont valides. Par conséquent, lorsque les clés ne sont pas valides, le comportement des implémentations n'est pas spécifié. L'implication de ce comportement non spécifié dépend de l'application. Les approches possibles pour aborder le problème de la validation des clés incluent : la validation explicite des clés par l'application ; la validation des clés au sein d'une infrastructure à clés publiques ; et l'attribution de la responsabilité d'effectuer des opérations avec des clés invalides à la partie qui a généré les clés.

Une pratique cryptographique généralement bonne est d'utiliser une paire de clés RSA donnée dans un seul schéma. Cela évite le risque qu'une vulnérabilité dans un schéma puisse compromettre la sécurité d'un autre, et peut être essentiel pour maintenir une sécurité prouvable (Provable Security). Bien que RSAES-PKCS1-v1_5 (Section 7.2) et RSASSA-PKCS1-v1_5 (Section 8.2) aient traditionnellement été utilisés ensemble sans aucune interaction indésirable connue (en fait, c'est le modèle introduit avec PKCS #1 v1.5), cette utilisation combinée de paires de clés RSA n'est PAS RECOMMANDÉE (NOT RECOMMENDED) pour les nouvelles applications.

Pour illustrer le risque associé à l'utilisation d'une paire de clés RSA dans plusieurs schémas, supposons qu'une paire de clés RSA soit utilisée à la fois pour RSAES-OAEP (Section 7.1) et RSAES-PKCS1-v1_5. Bien que RSAES-OAEP lui-même soit résistant aux attaques, un attaquant pourrait être en mesure d'exploiter une faiblesse dans une implémentation RSAES-PKCS1-v1_5 pour récupérer des messages chiffrés avec l'un ou l'autre schéma. Autre exemple, supposons qu'une paire de clés RSA soit utilisée à la fois pour RSASSA-PSS (Section 8.1) et RSASSA-PKCS1-v1_5. Dans ce cas, la preuve de sécurité de RSASSA-PSS ne serait plus suffisante, car la preuve ne prend pas en compte la possibilité que des signatures puissent être générées à l'aide du second schéma. Des considérations similaires peuvent s'appliquer si une paire de clés RSA est utilisée pour l'un des schémas définis ici et une variante définie ailleurs.

7. Schémas de chiffrement (Encryption Schemes)

Aux fins de ce document, un schéma de chiffrement (Encryption Scheme) est composé d'une opération de chiffrement et d'une opération de déchiffrement, où l'opération de chiffrement génère un texte chiffré à partir d'un message en utilisant la clé publique RSA du destinataire, et l'opération de déchiffrement récupère un message à partir d'un texte chiffré en utilisant la clé privée RSA correspondante du destinataire.

Les schémas de chiffrement peuvent être appliqués à une variété de scénarios d'application. Une application typique est le protocole d'établissement de clé (Key Establishment Protocol), où le message contient du matériel de clé qui doit être transféré en toute confidentialité d'une partie à une autre. Par exemple, PKCS #7 [RFC2315] utilise de tels protocoles pour transférer une clé de chiffrement de contenu d'un expéditeur à un destinataire ; les schémas de chiffrement définis dans ce document conviennent pour être utilisés comme algorithmes de chiffrement de clé dans ce contexte.

Ce document spécifie deux schémas de chiffrement : RSAES-OAEP et RSAES-PKCS1-v1_5. Les nouvelles applications DOIVENT (REQUIRED) prendre en charge RSAES-OAEP ; RSAES-PKCS1-v1_5 n'est inclus que pour la compatibilité avec les applications existantes.

Les schémas de chiffrement présentés ici suivent un modèle général similaire à celui utilisé dans IEEE 1363 [IEEE1363], combinant des primitives de chiffrement et de déchiffrement avec une méthode d'encodage pour le chiffrement. L'opération de chiffrement applique une opération d'encodage de message au message pour produire un message encodé, qui est ensuite converti en un représentant de message entier. La primitive de chiffrement est appliquée au représentant de message pour produire le texte chiffré. Inversement, l'opération de déchiffrement applique la primitive de déchiffrement au texte chiffré pour récupérer le représentant de message, qui est ensuite converti en une chaîne d'octets de message encodé. Une opération de décodage de message est appliquée au message encodé pour récupérer le message et vérifier l'exactitude du déchiffrement.

Pour éviter les faiblesses d'implémentation liées à la manière dont les erreurs sont gérées dans l'opération de décodage (voir [BLEICHENBACHER] et [MANGER]), les opérations d'encodage et de décodage de RSAES-OAEP et RSAES-PKCS1-v1_5 sont intégrées dans les spécifications des schémas de chiffrement respectifs, plutôt que d'être définies dans des spécifications séparées. Les deux schémas de chiffrement sont compatibles avec les schémas correspondants dans PKCS #1 v2.1.

7.1. RSAES-OAEP

RSAES-OAEP combine les primitives RSAEP et RSADP (Section 5.1) avec la méthode d'encodage EME-OAEP (intégrée dans cette section). Il est basé sur la méthode de rembourrage optimal de chiffrement asymétrique (Optimal Asymmetric Encryption Padding, OAEP) de Bellare et Rogaway, introduite pour la première fois dans [OAEP]. EME-OAEP est une variante unidirectionnelle de EME-OAEP dans IEEE 1363 [IEEE1363].

Le schéma n'est pas déterministe : pour une clé publique et un message donnés, de nombreux textes chiffrés possibles peuvent être générés.

RSAES-OAEP est recommandé pour les nouvelles applications. RSAES-OAEP peut être utilisé comme alternative préférable à RSAES-PKCS1-v1_5 dans toute application.

La sécurité de ce schéma est basée sur la difficulté de deux fonctions : le problème RSA et le modèle d'oracle aléatoire de la fonction de génération de masque (Mask Generation Function, MGF). Les propriétés de sécurité de ces deux fonctions sont incarnées dans une preuve de théorème montrant que la difficulté d'utiliser RSAES-OAEP contre une attaque par texte chiffré choisi (Chosen Ciphertext Attack) est essentiellement aussi difficile que de résoudre le problème RSA, à condition que le MGF se comporte comme un oracle aléatoire (Random Oracle).

7.1.1. Opération de chiffrement (Encryption Operation)

RSAES-OAEP-ENCRYPT ((n, e), M, L)

Entrée (Input):

(n, e): clé publique RSA du destinataire (k désigne la longueur en octets du module)
M: message à chiffrer, une chaîne d'octets de longueur au plus k - 2hLen - 2, où hLen est la longueur de sortie en octets de la fonction de hachage Hash
L: étiquette optionnelle (Label) associée à l'opération de chiffrement ; la valeur par défaut est la chaîne vide

Sortie (Output):

C: texte chiffré, une chaîne d'octets de longueur k

Erreurs (Errors):

"message too long" (message trop long)
"label too long" (étiquette trop longue)

Hypothèse (Assumption): La clé publique RSA (n, e) est valide

Étapes (Steps):

Vérification de longueur : Si la longueur de L est supérieure à la limite d'entrée pour la fonction de génération de masque (qui est 2^61 - 1 octets), sortir "label too long" et arrêter.
Encodage EME-OAEP :
- Si la longueur de M est supérieure à k - 2hLen - 2 octets, sortir "message too long" et arrêter.
- Soit lHash = Hash(L), une chaîne d'octets de longueur hLen.
- Générer une chaîne de rembourrage PS composée de k - mLen - 2hLen - 2 octets zéro et d'un seul octet de valeur 0x01.
- Concaténer lHash, PS, l'octet unique 0x01 et le message M pour former le bloc de données DB : DB = lHash || PS || 0x01 || M
- Générer une chaîne d'octets aléatoire seed de longueur hLen.
- Soit dbMask = MGF(seed, k - hLen - 1).
- Soit maskedDB = DB ⊕ dbMask.
- Soit seedMask = MGF(maskedDB, hLen).
- Soit maskedSeed = seed ⊕ seedMask.
- Concaténer un seul octet de valeur 0x00, maskedSeed et maskedDB pour former le message encodé EM : EM = 0x00 || maskedSeed || maskedDB
Chiffrement RSA :
- Convertir le message encodé EM en un représentant de message entier m : m = OS2IP(EM)
- Appliquer la primitive de chiffrement RSAEP : c = RSAEP((n, e), m)
- Convertir le représentant de texte chiffré c en un texte chiffré C de longueur k : C = I2OSP(c, k)
Sortir le texte chiffré C.

7.1.2. Opération de déchiffrement (Decryption Operation)

RSAES-OAEP-DECRYPT (K, C, L)

Entrée (Input):

K: clé privée RSA du destinataire
C: texte chiffré à déchiffrer, une chaîne d'octets de longueur k, où k est la longueur en octets du module RSA n
L: étiquette optionnelle dont la valeur est associée à l'étiquette lors de l'opération de chiffrement qui a généré le texte chiffré ; la valeur par défaut est la chaîne vide

Sortie (Output):

M: message, une chaîne d'octets de longueur au plus k - 2hLen - 2

Erreur (Error):

"decryption error" (erreur de déchiffrement)

Étapes (Steps):

Vérification de longueur : Si la longueur de L est supérieure à la limite d'entrée, sortir "decryption error" et arrêter. Si la longueur du texte chiffré C n'est pas de k octets (ou si k < 2hLen + 2), sortir "decryption error" et arrêter.
Déchiffrement RSA :
- Convertir le texte chiffré C en un représentant de texte chiffré entier c : c = OS2IP(C)
- Appliquer la primitive de déchiffrement RSADP : m = RSADP(K, c). Si RSADP sort "ciphertext representative out of range", sortir "decryption error" et arrêter.
- Convertir le représentant de message m en un message encodé EM de longueur k : EM = I2OSP(m, k)
Décodage EME-OAEP :
- Soit lHash = Hash(L).
- Séparer EM en un seul octet Y, une chaîne d'octets maskedSeed de longueur hLen, et une chaîne d'octets maskedDB de longueur k - hLen - 1 : EM = Y || maskedSeed || maskedDB
- Soit seedMask = MGF(maskedDB, hLen).
- Soit seed = maskedSeed ⊕ seedMask.
- Soit dbMask = MGF(seed, k - hLen - 1).
- Soit DB = maskedDB ⊕ dbMask.
- Séparer DB en une chaîne d'octets lHash' de longueur hLen, une chaîne de rembourrage PS (possiblement vide) composée d'octets de valeur 0x00, un seul octet de valeur 0x01, et un message M : DB = lHash' || PS || 0x01 || M. S'il n'y a pas d'octet de valeur 0x01 pour séparer PS et M, si lHash n'est pas égal à lHash', ou si Y est non nul, sortir "decryption error" et arrêter.
Sortir le message M.

Note : L'implémentation doit être effectuée avec soin pour éviter que l'implémentation ne fournisse par inadvertance des informations utiles à un adversaire. En particulier, les messages d'erreur ne doivent pas révéler si un octet dans EM ou d'autres octets dans DB ne sont pas de la forme attendue.

7.2. RSAES-PKCS1-v1_5

RSAES-PKCS1-v1_5 combine les primitives RSAEP et RSADP (Section 5.1) avec la méthode d'encodage EME-PKCS1-v1_5. Il n'est inclus que pour la compatibilité avec les applications existantes ; pour les nouvelles applications, l'utilisation de RSAES-OAEP est recommandée.

La sécurité de RSAES-PKCS1-v1_5 dépend de la difficulté du problème RSA. Des faiblesses potentielles connues (voir [BLEICHENBACHER]) existent, donc les nouvelles applications devraient utiliser RSAES-OAEP.

7.2.1. Opération de chiffrement (Encryption Operation)

RSAES-PKCS1-V1_5-ENCRYPT ((n, e), M)

Les entrées, sorties et étapes sont similaires à RSAES-OAEP, mais utilisent l'encodage EME-PKCS1-v1_5

7.2.2. Opération de déchiffrement (Decryption Operation)

RSAES-PKCS1-V1_5-DECRYPT (K, C)

Les entrées, sorties et étapes sont similaires à RSAES-OAEP, mais utilisent le décodage EME-PKCS1-v1_5

Remarque de sécurité importante : Les messages d'erreur de déchiffrement ne doivent pas distinguer différents types d'erreurs pour prévenir l'attaque par texte chiffré choisi de Bleichenbacher.

8. Schéma de signature avec appendice (Signature Scheme with Appendix)

Un schéma de signature avec appendice (Signature Scheme with Appendix) est composé d'une opération de génération de signature et d'une opération de vérification de signature, où l'opération de génération de signature génère une signature à partir d'un message en utilisant la clé privée RSA du signataire, et l'opération de vérification de signature vérifie l'authenticité de la signature en utilisant la clé publique RSA du signataire.

Pour signer un message M, le signataire applique une opération d'encodage de message à M pour générer un message encodé EM, puis applique la primitive de signature pour produire une signature S. Pour vérifier une signature S, le vérificateur applique la primitive de vérification à S pour récupérer le message encodé EM, puis applique l'opération de vérification pour déterminer si la signature est valide pour le message.

Deux schémas de signature sont spécifiés dans ce document : RSASSA-PSS et RSASSA-PKCS1-v1_5.

Bien que non obligatoire, RSASSA-PSS est recommandé pour les nouvelles applications. RSASSA-PKCS1-v1_5 est inclus pour la compatibilité avec les applications existantes.

8.1. RSASSA-PSS

RSASSA-PSS combine les primitives RSASP1 et RSAVP1 (Section 5.2) avec la méthode d'encodage EMSA-PSS. Il est basé sur le schéma de signature probabiliste (Probabilistic Signature Scheme, PSS) proposé par Bellare et Rogaway [RSARABIN] [PSS].

La sécurité de PSS est basée sur la difficulté du problème RSA et le modèle d'oracle aléatoire du MGF. Il a été prouvé que sous le modèle d'oracle aléatoire, si le MGF se comporte comme un oracle aléatoire et que le problème RSA est difficile, alors le schéma de signature PSS est sécurisé contre les attaques par message choisi (Chosen Message Attack).

RSASSA-PSS n'est pas déterministe : pour un message donné, plusieurs signatures possibles peuvent être générées. Cela est dû à l'inclusion d'une valeur de sel aléatoire pendant l'opération de génération de signature.

8.1.1. Opération de génération de signature (Signature Generation Operation)

RSASSA-PSS-SIGN (K, M)

Entrée (Input):

K: clé privée RSA du signataire
M: message à signer, une chaîne d'octets de longueur arbitraire

Sortie (Output):

S: signature, une chaîne d'octets de longueur k, où k est la longueur en octets du module RSA n

Erreurs (Errors):

"message too long" (message trop long)
"encoding error" (erreur d'encodage)

Étapes (Steps):

Encodage EMSA-PSS : Appliquer l'opération d'encodage EMSA-PSS au message M pour générer un message encodé EM de longueur ⌈(modBits-1)/8⌉ octets, où modBits est la longueur en bits du module RSA n : EM = EMSA-PSS-ENCODE(M, modBits - 1). Si l'opération d'encodage sort "message too long" ou "encoding error", sortir l'erreur correspondante et arrêter.
Signature RSA :
- Convertir le message encodé EM en un représentant de message entier m : m = OS2IP(EM)
- Appliquer la primitive de signature RSASP1 : s = RSASP1(K, m)
- Convertir le représentant de signature s en une signature S de longueur k : S = I2OSP(s, k)
Sortir la signature S.

8.1.2. Opération de vérification de signature (Signature Verification Operation)

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

Entrée (Input):

(n, e): clé publique RSA du signataire
M: message, une chaîne d'octets de longueur arbitraire
S: signature à vérifier, une chaîne d'octets de longueur k

Sortie (Output):

"valid signature" (signature valide) ou "invalid signature" (signature invalide)

Étapes (Steps):

Vérification de longueur : Si la longueur de la signature S n'est pas de k octets, sortir "invalid signature" et arrêter.
Vérification RSA :
- Convertir la signature S en un représentant de signature entier s : s = OS2IP(S)
- Appliquer la primitive de vérification RSAVP1 : m = RSAVP1((n, e), s). Si RSAVP1 sort "signature representative out of range", sortir "invalid signature" et arrêter.
- Convertir le représentant de message m en un message encodé EM de longueur emLen = ⌈(modBits - 1)/8⌉ : EM = I2OSP(m, emLen)
Vérification EMSA-PSS : Appliquer l'opération de vérification EMSA-PSS : Result = EMSA-PSS-VERIFY(M, EM, modBits - 1). Si Result = "consistent", sortir "valid signature" ; sinon sortir "invalid signature".

8.2. RSASSA-PKCS1-v1_5

RSASSA-PKCS1-v1_5 combine les primitives RSASP1 et RSAVP1 (Section 5.2) avec la méthode d'encodage EMSA-PKCS1-v1_5. Il est compatible avec le schéma IFSSA dans IEEE 1363 [IEEE1363], où la fonction de hachage de la valeur DigestInfo est utilisée pour générer le représentant de message.

La sécurité de RSASSA-PKCS1-v1_5 dépend de la difficulté du problème RSA. Bien qu'il n'y ait pas d'attaque connue qui réussisse à casser ce schéma, il n'y a pas non plus de preuve de sécurité comme pour PSS.

8.2.1. Opération de génération de signature (Signature Generation Operation)

RSASSA-PKCS1-V1_5-SIGN (K, M)

Les étapes sont similaires à RSASSA-PSS, mais utilisent la méthode d'encodage EMSA-PKCS1-v1_5

8.2.2. Opération de vérification de signature (Signature Verification Operation)

RSASSA-PKCS1-V1_5-VERIFY ((n, e), M, S)

Les étapes sont similaires à RSASSA-PSS, mais utilisent la méthode de vérification EMSA-PKCS1-v1_5

9. Méthodes d'encodage pour signatures avec appendice (Encoding Methods for Signatures with Appendix)

Les méthodes d'encodage sont utilisées pour convertir un message en un message encodé, qui peut ensuite être signé par les primitives de signature RSA. Cette section spécifie deux méthodes d'encodage : EMSA-PSS et EMSA-PKCS1-v1_5.

9.1. EMSA-PSS

EMSA-PSS (Encoding Method for Signatures with Appendix - Probabilistic Signature Scheme) est une méthode d'encodage probabiliste qui contient de l'aléatoire, et peut donc générer plusieurs messages encodés différents pour un message donné.

9.1.1. Opération d'encodage (Encoding Operation)

EMSA-PSS-ENCODE (M, emBits)

Entrée (Input):

M: message à encoder, une chaîne d'octets de longueur arbitraire
emBits: longueur maximale en bits du message encodé, au moins 8hLen + 8sLen + 9

Sortie (Output):

EM: message encodé, une chaîne d'octets de longueur emLen = ⌈emBits/8⌉

Étapes (Steps):

Si la longueur de M est supérieure à la limite d'entrée de la fonction de hachage Hash (2^61 - 1 octets pour SHA-1), sortir "message too long" et arrêter.
Soit mHash = Hash(M), une chaîne d'octets de longueur hLen.
Si emLen < hLen + sLen + 2, sortir "encoding error" et arrêter.
Générer une chaîne d'octets aléatoire salt de longueur sLen.
Soit M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt ; M' est une chaîne d'octets de longueur 8 + hLen + sLen.
Soit H = Hash(M'), une chaîne d'octets de longueur hLen.
Générer une chaîne d'octets PS composée de emLen - sLen - hLen - 2 octets zéro.
Soit DB = PS || 0x01 || salt ; DB est une chaîne d'octets de longueur emLen - hLen - 1.
Soit dbMask = MGF(H, emLen - hLen - 1).
Soit maskedDB = DB ⊕ dbMask.
Définir les 8emLen - emBits bits les plus à gauche de maskedDB à zéro.
Soit EM = maskedDB || H || 0xbc.
Sortir EM.

9.1.2. Opération de vérification (Verification Operation)

EMSA-PSS-VERIFY (M, EM, emBits)

Entrée (Input):

M: message, une chaîne d'octets de longueur arbitraire
EM: message encodé à vérifier, une chaîne d'octets de longueur emLen = ⌈emBits/8⌉
emBits: longueur maximale en bits du message encodé

Sortie (Output):

"consistent" (cohérent) ou "inconsistent" (incohérent)

Étapes : (les étapes de vérification sont l'inverse des étapes d'encodage, vérifiant toutes les contraintes)

9.2. EMSA-PKCS1-v1_5

EMSA-PKCS1-v1_5 (Encoding Method for Signatures with Appendix - PKCS #1 v1.5) est une méthode d'encodage déterministe qui génère toujours le même message encodé pour un message donné.

EMSA-PKCS1-v1_5-ENCODE (M, emLen)

Entrée (Input):

M: message à encoder, une chaîne d'octets de longueur arbitraire
emLen: longueur attendue du message encodé (en octets), au moins tLen + 11, où tLen est la longueur en octets de la valeur DigestInfo

Sortie (Output):

EM: message encodé, une chaîne d'octets de longueur emLen

Étapes (Steps):

Appliquer la fonction de hachage au message M pour générer la valeur de hachage H : H = Hash(M). Si la fonction de hachage sort "message too long", sortir "message too long" et arrêter.
En utilisant la technique de la note de la Section 9.2, encoder la valeur DigestInfo comme T pour la fonction de hachage.
Si emLen < tLen + 11, sortir "intended encoded message length too short" et arrêter.
Générer une chaîne d'octets PS composée de emLen - tLen - 3 octets de valeur 0xff.
Concaténer PS et autres paddings pour former le message encodé EM : EM = 0x00 || 0x01 || PS || 0x00 || T
Sortir EM.

10. Considérations de sécurité (Security Considerations)

Les considérations de sécurité ont été abordées tout au long de ce document.

Points de sécurité essentiels

Longueur des clés

La sécurité des clés RSA dépend fortement de la taille du module. Longueurs de clé minimales recommandées :

2048 bits : longueur minimale recommandée actuellement.
3072 bits : recommandée pour les applications à haute sécurité.
4096 bits : pour les clés à long terme ou les exigences de sécurité très élevées.

Choix des schémas

RSAES-OAEP : schéma de chiffrement OBLIGATOIRE (REQUIRED) à prendre en charge dans les nouvelles applications.
RSASSA-PSS : schéma de signature RECOMMANDÉ (RECOMMENDED) pour les nouvelles applications.
PKCS1-v1_5 : conservé uniquement pour la compatibilité ; présente des faiblesses connues.

Points d'attention pour l'implémentation

Génération de nombres aléatoires : un générateur de nombres aléatoires cryptographiquement sûr doit être utilisé.
Attaques par canal auxiliaire : l'implémentation devrait empêcher les attaques par mesure du temps et l'analyse de la consommation.
Gestion des erreurs : les messages d'erreur des opérations de déchiffrement et de vérification doivent être uniformes pour éviter les fuites d'information.
Attaques par oracle de bourrage : RSAES-PKCS1-v1_5 est sensible à l'attaque de Bleichenbacher ; une attention particulière est requise lors de l'implémentation.

Fonctions de hachage

À éviter : MD5, SHA-1 (cassés).
Recommandées : SHA-256, SHA-384, SHA-512.

Utilisation des clés

Usage unique : une paire de clés RSA ne devrait être utilisée que pour un seul schéma (chiffrement ou signature, sans mélange).
Rotation des clés : remplacer les clés régulièrement.
Protection de la clé privée : la clé privée doit être stockée chiffrée ; l'utilisation d'un module matériel de sécurité (HSM) constitue une bonne pratique.

Attaques connues et défenses

Attaque à chiffré choisi (Chosen Ciphertext Attack) : RSAES-OAEP offre une protection.
Attaque à message choisi (Chosen Message Attack) : RSASSA-PSS offre une protection.
Attaque de Bleichenbacher : touche RSAES-PKCS1-v1_5.
Attaques par mesure du temps : l'utilisation d'algorithmes à temps constant est nécessaire ; attention en particulier lors de l'accélération CRT.

Voir la section 6 pour la discussion sur l'évitement de l'utilisation d'une même paire de clés dans plusieurs schémas.

Appendix A. Syntaxe ASN.1 (ASN.1 Syntax)

Cette annexe résume la syntaxe ASN.1 utilisée dans ce document. L'annexe C contient le module ASN.1 complet.

A.1. RSA Key Representation (Représentation des clés RSA)

Cette section définit la syntaxe ASN.1 pour les clés publiques et privées RSA.

A.1.1. RSA Public Key Syntax (Syntaxe de clé publique RSA)

La clé publique RSA doit être représentée comme le type ASN.1 RSAPublicKey :

RSAPublicKey ::= SEQUENCE {
    modulus           INTEGER,  -- n
    publicExponent    INTEGER   -- e
}

Description des champs :

modulus : Module RSA n
publicExponent : Exposant de clé publique RSA e

Dans une clé publique RSA valide, la valeur du module n doit être le produit de u nombres premiers impairs distincts r_i (i = 1, 2, ..., u), où u >= 2, et l'exposant de clé publique e doit être un entier entre 3 et n - 1, satisfaisant GCD(e, λ(n)) = 1.

A.1.2. RSA Private Key Syntax (Syntaxe de clé privée RSA)

La clé privée RSA doit être représentée comme le type ASN.1 RSAPrivateKey :

RSAPrivateKey ::= SEQUENCE {
    version           Version,
    modulus           INTEGER,  -- n
    publicExponent    INTEGER,  -- e
    privateExponent   INTEGER,  -- d
    prime1            INTEGER,  -- p
    prime2            INTEGER,  -- q
    exponent1         INTEGER,  -- d mod (p-1)
    exponent2         INTEGER,  -- d mod (q-1)
    coefficient       INTEGER,  -- (inverse of q) mod p
    otherPrimeInfos   OtherPrimeInfos OPTIONAL
}

Version ::= INTEGER { two-prime(0), multi(1) }
    (CONSTRAINED BY {
        -- version must be multi if otherPrimeInfos present --
    })

OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo

OtherPrimeInfo ::= SEQUENCE {
    prime             INTEGER,  -- r_i
    exponent          INTEGER,  -- d_i
    coefficient       INTEGER   -- t_i
}

Description des champs :

version : Numéro de version (two-prime indique RSA à deux premiers, multi indique RSA multi-premier)
modulus : Module RSA n
publicExponent : Exposant de clé publique RSA e
privateExponent : Exposant de clé privée RSA d
prime1 : Premier facteur premier p
prime2 : Deuxième facteur premier q
exponent1 : d mod (p-1)
exponent2 : d mod (q-1)
coefficient : Coefficient CRT qInv, (q^-1) mod p
otherPrimeInfos : Optionnel, utilisé pour les informations de facteurs premiers supplémentaires pour RSA multi-premier

A.2. Scheme Identification (Identification des schémas)

Cette section définit les identificateurs d'objets (Object Identifiers) pour les différents schémas définis dans ce document.

A.2.1. RSAES-OAEP

Identificateur d'objet pour le schéma de chiffrement RSAES-OAEP :

id-RSAES-OAEP OBJECT IDENTIFIER ::= { pkcs-1 7 }

Type de paramètres d'algorithme pour RSAES-OAEP :

RSAES-OAEP-params ::= SEQUENCE {
    hashFunc          [0] AlgorithmIdentifier DEFAULT sha1,
    maskGenFunc       [1] AlgorithmIdentifier DEFAULT mgf1SHA1,
    pSourceFunc       [2] AlgorithmIdentifier DEFAULT pSpecifiedEmpty
}

A.2.2. RSAES-PKCS1-v1_5

Identificateur d'objet pour le schéma de chiffrement RSAES-PKCS1-v1_5 :

id-RSAES-PKCS1-v1_5 OBJECT IDENTIFIER ::= { pkcs-1 1 }

Ce schéma n'a pas de paramètres associés.

A.2.3. RSASSA-PSS

Identificateur d'objet pour le schéma de signature RSASSA-PSS :

id-RSASSA-PSS OBJECT IDENTIFIER ::= { pkcs-1 10 }

Type de paramètres d'algorithme pour RSASSA-PSS :

RSASSA-PSS-params ::= SEQUENCE {
    hashAlgorithm      [0] AlgorithmIdentifier DEFAULT sha1,
    maskGenAlgorithm   [1] AlgorithmIdentifier DEFAULT mgf1SHA1,
    saltLength         [2] INTEGER DEFAULT 20,
    trailerField       [3] INTEGER DEFAULT 1
}

A.2.4. RSASSA-PKCS1-v1_5

Le schéma de signature RSASSA-PKCS1-v1_5 utilise les identificateurs d'objets suivants pour différentes fonctions de hachage :

sha256WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 11 }
sha384WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 12 }
sha512WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 13 }

Ces identificateurs d'objets sont associés à des fonctions de hachage spécifiques.

Appendix B. Techniques de support (Supporting Techniques)

Cette annexe contient les spécifications des techniques de support utilisées dans ce document, y compris les fonctions de hachage et les fonctions de génération de masque.

B.1. Hash Functions (Fonctions de hachage)

Les fonctions de hachage sont utilisées pour mapper des messages de longueur arbitraire à des sorties de longueur fixe. Les fonctions de hachage utilisées dans les schémas de ce document doivent satisfaire les propriétés suivantes :

Résistance à la préimage (Preimage Resistance) : Étant donné une valeur de hachage h, il est computationnellement infaisable de trouver un message m tel que Hash(m) = h
Résistance à la seconde préimage (Second Preimage Resistance) : Étant donné un message m1, il est computationnellement infaisable de trouver un message différent m2 tel que Hash(m1) = Hash(m2)
Résistance aux collisions (Collision Resistance) : Il est computationnellement infaisable de trouver deux messages différents m1 et m2 quelconques tels que Hash(m1) = Hash(m2)

Fonctions de hachage recommandées

Ce document recommande l'utilisation des fonctions de hachage suivantes :

Fonction de hachage	Longueur de sortie(bits)	Longueur de sortie(octets)	État
SHA-1	160	20	⚠️ Obsolète(compatibilité descendante uniquement)
SHA-256	256	32	✅ Recommandé
SHA-384	384	48	✅ Recommandé
SHA-512	512	64	✅ Recommandé
SHA-512/224	224	28	✅ Disponible
SHA-512/256	256	32	✅ Disponible

Identification ASN.1 des fonctions de hachage

Identificateur d'algorithme pour SHA-256 :

id-sha256 OBJECT IDENTIFIER ::= {
    joint-iso-itu-t(2) country(16) us(840) organization(1)
    gov(101) csor(3) nistalgorithm(4) hashalgs(2) 1
}

Identificateur d'algorithme pour SHA-384 :

id-sha384 OBJECT IDENTIFIER ::= {
    joint-iso-itu-t(2) country(16) us(840) organization(1)
    gov(101) csor(3) nistalgorithm(4) hashalgs(2) 2
}

Identificateur d'algorithme pour SHA-512 :

id-sha512 OBJECT IDENTIFIER ::= {
    joint-iso-itu-t(2) country(16) us(840) organization(1)
    gov(101) csor(3) nistalgorithm(4) hashalgs(2) 3
}

B.2. Mask Generation Functions (Fonctions de génération de masque)

Une fonction de génération de masque (Mask Generation Function, MGF) prend en entrée une chaîne d'octets de longueur variable et une longueur de sortie requise, et génère une chaîne d'octets de sortie de longueur spécifiée. Les fonctions de génération de masque peuvent être basées sur des fonctions de hachage ou d'autres fonctions.

L'utilisation principale des fonctions de génération de masque est de générer des données d'apparence aléatoire dans les schémas de remplissage.

B.2.1. MGF1

MGF1 est une fonction de génération de masque basée sur une fonction de hachage. MGF1 (mgfSeed, maskLen) prend en entrée une graine de longueur variable et une longueur de masque requise, et produit un masque de longueur spécifiée.

MGF1 (mgfSeed, maskLen)

Entrée (Input)

mgfSeed     Graine de génération de masque, chaîne d'octets de longueur arbitraire
maskLen     Longueur attendue du masque(en octets)

Sortie (Output)

mask        Masque de longueur maskLen, chaîne d'octets

Erreur (Error)

"mask too long" (masque trop long)

Étapes (Steps)

Si maskLen > 2^32 * hLen, sortir "mask too long" et s'arrêter.
Soit T une chaîne d'octets vide.
Pour le compteur C de 0 à ⌈maskLen / hLen⌉ - 1 :
- Convertir le compteur C en chaîne d'octets C de longueur 4 : C = I2OSP(C, 4)
- Concaténer le hachage de mgfSeed et C à T : T = T || Hash(mgfSeed || C)
Sortir les maskLen premiers octets de T comme masque.

Options MGF1 (MGF1 Options)

La fonction de hachage par défaut de MGF1 est SHA-1. Pour les nouvelles applications, l'utilisation de SHA-256 ou d'une fonction de hachage supérieure est recommandée.

Identification ASN.1 de MGF1 avec SHA-256 :

id-mgf1 OBJECT IDENTIFIER ::= { pkcs-1 8 }

-- Le paramètre de MGF1 est la fonction de hachage utilisée
AlgorithmIdentifier { ALGORITHM:IOSet } ::= SEQUENCE {
    algorithm   ALGORITHM.&id({IOSet}),
    parameters  ALGORITHM.&Type({IOSet}{@algorithm}) OPTIONAL
}

Considérations de sécurité pour MGF

Dans le modèle de l'oracle aléatoire, si la fonction de hachage sous-jacente se comporte bien, la sortie de MGF1 est computationnellement indiscernable d'une chaîne véritablement aléatoire. Cela rend MGF1 adapté pour une utilisation dans des schémas tels que OAEP et PSS.

Appendix D. Historique des révisions de PKCS #1 (Revision History of PKCS #1)

Évolution des versions

PKCS #1 v1.5 (novembre 1993)

Contenu: Définition des schémas de base pour le chiffrement et la signature RSA
Chiffrement: RSAES-PKCS1-v1_5
Signature: RSASSA-PKCS1-v1_5
État: Largement déployé, mais présente des faiblesses de sécurité connues

PKCS #1 v2.0 (septembre 1998, RFC 2437)

Ajout: Schéma de chiffrement RSAES-OAEP
Ajout: Schéma de signature RSASSA-PSS
Amélioration: Introduction de schémas sécurisés basés sur des preuves
Conservation: Schémas v1.5 pour maintenir la compatibilité ascendante

PKCS #1 v2.1 (juin 2002, RFC 3447)

Amélioration: Mise à jour des spécifications RSAES-OAEP et RSASSA-PSS
Ajout: Support de fonctions de hachage supplémentaires (SHA-256, SHA-384, SHA-512)
Ajout: Module ASN.1 complet
Clarification: Utilisation du RSA multi-premier

PKCS #1 v2.2 (octobre 2012 / novembre 2016, RFC 8017)

Amélioration: Clarifications techniques et corrections d'errata
Mise à jour: Description améliorée des considérations de sécurité
Ajout: Support pour SHA-512/224 et SHA-512/256
État: Version actuelle, publiée en tant que RFC 8017

Résumé des changements principaux

v1.5 → v2.0: Introduction des schémas OAEP et PSS prouvablement sécurisés
v2.0 → v2.1: Support amélioré des fonctions de hachage et RSA multi-premier
v2.1 → v2.2: Clarifications techniques et mise à jour des recommandations de sécurité
Transfert RFC: Du PKCS de RSA Labs à la série RFC de l'IETF

Note sur les dépréciations

RFC 3447 (PKCS #1 v2.1) est obsolète par ce document (RFC 8017, PKCS #1 v2.2)
RSAES-PKCS1-v1_5 est conservé uniquement pour la compatibilité ascendante, non recommandé pour les nouvelles applications
SHA-1 n'est plus recommandé en raison d'attaques par collision connues

Remarques sur la compatibilité

Bien que de nouveaux schémas aient été introduits entre les versions, pour la compatibilité ascendante:

Les schémas v1.5 sont maintenus dans toutes les versions
Les schémas nouvellement ajoutés (OAEP, PSS) coexistent avec les anciennes implémentations
La syntaxe ASN.1 maintient la compatibilité ascendante

Appendix E. À propos de PKCS (About PKCS)

À propos des normes de cryptographie à clé publique (Public-Key Cryptography Standards)

Les normes de cryptographie à clé publique (PKCS, Public-Key Cryptography Standards) sont des spécifications élaborées par RSA Laboratories en collaboration avec des développeurs de l'industrie et du monde académique, visant à accélérer le déploiement des technologies de cryptographie à clé publique.

Vue d'ensemble de la série PKCS

La série PKCS a été initialement lancée par RSA Security Inc. (anciennement RSA Data Security, Inc.) et comprend plusieurs normes:

Norme	Nom	État
PKCS #1	Spécifications de cryptographie RSA	✅ Ce document (RFC 8017)
PKCS #3	Norme d'accord de clé Diffie-Hellman	-
PKCS #5	Spécifications de cryptographie basée sur mot de passe	RFC 2898, RFC 8018
PKCS #6	Norme de syntaxe de certificat étendu	Obsolète
PKCS #7	Norme de syntaxe de message cryptographique	RFC 2315 (remplacé par CMS)
PKCS #8	Spécification de syntaxe d'information de clé privée	RFC 5208, RFC 5958
PKCS #9	Types d'attributs sélectionnés	RFC 2985
PKCS #10	Spécification de syntaxe de demande de certificat	RFC 2986
PKCS #11	Interface de jeton cryptographique (Cryptoki)	Norme OASIS
PKCS #12	Norme de syntaxe d'échange d'informations personnelles	RFC 7292
PKCS #15	Norme de format d'information de jeton cryptographique	ISO/IEC 7816-15

Signification historique de PKCS #1

PKCS #1 est l'une des normes les plus anciennes et les plus importantes de la série PKCS, définissant la méthode d'implémentation standardisée de la cryptographie RSA:

Adoption industrielle: PKCS #1 est largement adopté dans les protocoles SSL/TLS, SSH, S/MIME, PGP, etc.
Impact sur la normalisation: A influencé les normes internationales telles que IEEE 1363, ISO/IEC 18033
Contribution académique: L'introduction des schémas OAEP et PSS a favorisé le développement de la cryptographie prouvablement sécurisée

De RSA Labs à l'IETF

À partir du milieu des années 2000, les normes de la série PKCS ont progressivement été transférées à des organisations de normalisation ouvertes:

IETF: PKCS #1, #5, #7, #8, #9, #10, #12 convertis en RFC
OASIS: PKCS #11 (Cryptoki) converti en norme OASIS
ISO/IEC: PKCS #15 intégré dans la norme ISO/IEC 7816

Ce document (RFC 8017) représente le transfert du contrôle de PKCS #1 de RSA Labs à l'IETF, garantissant la maintenance et l'évolution continues de cette norme.

Remerciements (Acknowledgements)

Le développement de PKCS #1 a bénéficié de nombreuses contributions de la communauté cryptographique, notamment:

Auteurs originaux: Burt Kaliski, Jake Lacy
Fondements théoriques: Mihir Bellare, Phillip Rogaway (schémas OAEP et PSS)
Contributeurs v2.0-v2.2: Jakob Jonsson, Burt Kaliski, Kathleen Moriarty, Andreas Rusch
Revue et retour d'information: Révision extensive de la communauté IETF, RSA Labs et du monde académique

Plus d'informations

Groupe de travail PKCS de l'IETF: https://datatracker.ietf.org/wg/pkcs/
RSA Labs: http://www.rsa.com/rsalabs/
Archives PKCS: https://www.emc.com/emc-plus/rsa-labs/standards-initiatives/pkcs.htm

Résumé (Abstract)​

Statut de ce mémo​

Table des matières​

Annexes​

Ressources connexes​

1. Introduction​

1.1. Langage des exigences (Requirements Language)​

2. Notation​

3. Types de clés (Key Types)​

3.1. Clé publique RSA (RSA Public Key)​

3.2. Clé privée RSA (RSA Private Key)​

Représentation 1​

Représentation 2​

Contraintes de validité​

Notes​

4. Primitives de conversion de données (Data Conversion Primitives)​

4.1. I2OSP​

Entrée (Input)​

Sortie (Output)​

Erreur (Error)​

Étapes (Steps)​

4.2. OS2IP​

Entrée (Input)​

Sortie (Output)​

Étapes (Steps)​

5. Primitives cryptographiques (Cryptographic Primitives)​

5.1. Primitives de chiffrement et de déchiffrement (Encryption and Decryption Primitives)​

5.1.1. RSAEP​

Entrée (Input)​

Sortie (Output)​

Erreur (Error)​

Hypothèse (Assumption)​

Étapes (Steps)​

5.1.2. RSADP​

Entrée (Input)​

Sortie (Output)​

Erreur (Error)​

Hypothèse (Assumption)​

Étapes (Steps)​

5.2. Primitives de signature et de vérification (Signature and Verification Primitives)​

5.2.1. RSASP1​

Entrée (Input)​

Sortie (Output)​

Erreur (Error)​

Hypothèse (Assumption)​

Étapes (Steps)​

5.2.2. RSAVP1​

Entrée (Input)​

Sortie (Output)​

Erreur (Error)​

Hypothèse (Assumption)​

Étapes (Steps)​

6. Vue d'ensemble des schémas (Overview of Schemes)​

7. Schémas de chiffrement (Encryption Schemes)​

7.1. RSAES-OAEP​

7.1.1. Opération de chiffrement (Encryption Operation)​

7.1.2. Opération de déchiffrement (Decryption Operation)​

7.2. RSAES-PKCS1-v1_5​

7.2.1. Opération de chiffrement (Encryption Operation)​

7.2.2. Opération de déchiffrement (Decryption Operation)​

8. Schéma de signature avec appendice (Signature Scheme with Appendix)​

8.1. RSASSA-PSS​

8.1.1. Opération de génération de signature (Signature Generation Operation)​

8.1.2. Opération de vérification de signature (Signature Verification Operation)​

8.2. RSASSA-PKCS1-v1_5​

8.2.1. Opération de génération de signature (Signature Generation Operation)​

8.2.2. Opération de vérification de signature (Signature Verification Operation)​

9. Méthodes d'encodage pour signatures avec appendice (Encoding Methods for Signatures with Appendix)​

9.1. EMSA-PSS​

9.1.1. Opération d'encodage (Encoding Operation)​

9.1.2. Opération de vérification (Verification Operation)​

9.2. EMSA-PKCS1-v1_5​

10. Considérations de sécurité (Security Considerations)​

Points de sécurité essentiels​

Longueur des clés​

Choix des schémas​

Points d'attention pour l'implémentation​

Fonctions de hachage​

Utilisation des clés​

Attaques connues et défenses​

Résumé (Abstract)

Statut de ce mémo

Table des matières

Annexes

Ressources connexes

1. Introduction

1.1. Langage des exigences (Requirements Language)

2. Notation

3. Types de clés (Key Types)

3.1. Clé publique RSA (RSA Public Key)

3.2. Clé privée RSA (RSA Private Key)

Représentation 1

Représentation 2

Contraintes de validité

Notes

4. Primitives de conversion de données (Data Conversion Primitives)

4.1. I2OSP

Entrée (Input)

Sortie (Output)

Erreur (Error)

Étapes (Steps)

4.2. OS2IP

Entrée (Input)

Sortie (Output)

Étapes (Steps)

5. Primitives cryptographiques (Cryptographic Primitives)

5.1. Primitives de chiffrement et de déchiffrement (Encryption and Decryption Primitives)

5.1.1. RSAEP

Entrée (Input)

Sortie (Output)

Erreur (Error)

Hypothèse (Assumption)

Étapes (Steps)

5.1.2. RSADP

Entrée (Input)

Sortie (Output)

Erreur (Error)

Hypothèse (Assumption)

Étapes (Steps)

5.2. Primitives de signature et de vérification (Signature and Verification Primitives)

5.2.1. RSASP1

Entrée (Input)

Sortie (Output)

Erreur (Error)

Hypothèse (Assumption)

Étapes (Steps)

5.2.2. RSAVP1

Entrée (Input)

Sortie (Output)

Erreur (Error)

Hypothèse (Assumption)

Étapes (Steps)

6. Vue d'ensemble des schémas (Overview of Schemes)

7. Schémas de chiffrement (Encryption Schemes)

7.1. RSAES-OAEP

7.1.1. Opération de chiffrement (Encryption Operation)

7.1.2. Opération de déchiffrement (Decryption Operation)

7.2. RSAES-PKCS1-v1_5

7.2.1. Opération de chiffrement (Encryption Operation)

7.2.2. Opération de déchiffrement (Decryption Operation)

8. Schéma de signature avec appendice (Signature Scheme with Appendix)

8.1. RSASSA-PSS

8.1.1. Opération de génération de signature (Signature Generation Operation)

8.1.2. Opération de vérification de signature (Signature Verification Operation)

8.2. RSASSA-PKCS1-v1_5

8.2.1. Opération de génération de signature (Signature Generation Operation)

8.2.2. Opération de vérification de signature (Signature Verification Operation)

9. Méthodes d'encodage pour signatures avec appendice (Encoding Methods for Signatures with Appendix)

9.1. EMSA-PSS

9.1.1. Opération d'encodage (Encoding Operation)

9.1.2. Opération de vérification (Verification Operation)

9.2. EMSA-PKCS1-v1_5

10. Considérations de sécurité (Security Considerations)

Points de sécurité essentiels

Longueur des clés

Choix des schémas

Points d'attention pour l'implémentation

Fonctions de hachage

Utilisation des clés

Attaques connues et défenses