Remplissage optimal du chiffrement asymétrique

{\displaystyle f </span referrerpolicy=

Ce traitement, dans le cadre du modèle de l'oracle aléatoire, aboutit à un schéma combiné sémantiquement sûr face aux attaques à texte clair choisi (IND-CPA) . Implémenté avec certaines permutations de porte dérobée (par exemple, RSA), OAEP s'avère également sûr face aux attaques à texte chiffré choisi. OAEP permet de construire une transformation tout-ou-rien .

L’OAEP remplit les deux objectifs suivants :

Ajouter un élément d'aléatoire qui peut être utilisé pour convertir un schéma de chiffrement déterministe (par exemple, RSA traditionnel ) en un schéma probabiliste .
Empêcher le déchiffrement partiel des textes chiffrés (ou toute autre fuite d'informations) en s'assurant qu'un adversaire ne puisse récupérer aucune partie du texte clair sans être en mesure d'inverser la permutation unidirectionnelle de la porte dérobée. ${\displaystyle f <semantics><mrow><mstyle><mi>f</mi></mstyle></mrow><annotation>{\displaystyle f}</annotation></semantics></math><img src=$

La version originale d'OAEP (Bellare/Rogaway, 1994) présentait une forme de « conscience du texte clair » (qui, selon leurs auteurs, impliquait une sécurité contre les attaques à texte chiffré choisi ) dans le modèle de l'oracle aléatoire lorsque OAEP était utilisé avec une permutation à trappe quelconque. Des résultats ultérieurs ont contredit cette affirmation, montrant qu'OAEP n'était sûr qu'à IND-CCA1 . Cependant, il a été prouvé que le schéma original était sûr à IND-CCA2 dans le modèle de l'oracle aléatoire lorsque OAEP était utilisé avec la permutation RSA en utilisant des exposants de chiffrement standard, comme dans le cas de RSA-OAEP. Un schéma amélioré (appelé OAEP+) fonctionnant avec toute permutation à trappe unidirectionnelle a été proposé par Victor Shoup pour résoudre ce problème. Des travaux plus récents ont montré que dans le modèle standard (c'est-à-dire lorsque les fonctions de hachage ne sont pas modélisées comme des oracles aléatoires), il est impossible de prouver la sécurité IND-CCA2 de RSA-OAEP sous l'hypothèse de difficulté du problème RSA .

Algorithme

Dans le diagramme,

MGF est la fonction génératrice de masque , généralement MGF1,
Hash est la fonction de hachage choisie .
hLen représente la longueur de la sortie de la fonction de hachage en octets.
k est la longueur du module RSA n en octets,
M est le message à compléter, de longueur mLen (au maximum ${\displaystyle \mathrm {mLen} =k-2\cdot \mathrm {hLen} -2 <semantics><mrow><mstyle><mrow><mi>m</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>=</mo><mi>k</mi><mo>−</mo><mn>2</mn><mo>⋅</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>2</mn></mstyle></mrow><annotation>{ displaystyle mathrm {mLen} = k-2 cdot mathrm {hLen} -2}</annotation></semantics></math><img src=$
L est une étiquette facultative à associer au message (l'étiquette est une chaîne vide par défaut et peut être utilisée pour authentifier des données sans nécessiter de chiffrement).
PS est une chaîne d'octets de ${\displaystyle k-\mathrm {mLen} -2\cdot \mathrm {hLen} -2 <semantics><mrow><mstyle><mi>k</mi><mo>−</mo><mrow><mi>m</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>2</mn><mo>⋅</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>2</mn></mstyle></mrow><annotation>{ displaystyle k- mathrm {mLen} -2 cdot mathrm {hLen} -2}</annotation></semantics></math><img src=$
⊕ est une opération XOR .

Codage

pour PKCS#1 v2.2 spécifie le schéma OAEP comme suit pour l'encodage :

Hachez l'étiquette L en utilisant la fonction de hachage choisie : ${\displaystyle \mathrm {lHash} =\mathrm {Hash} (L) <semantics><mrow><mstyle><mrow><mi>l</mi><mi>H</mi><mi>un</mi><mi>s</mi><mi>h</mi></mrow><mo>=</mo><mrow><mi>H</mi><mi>un</mi><mi>s</mi><mi>h</mi></mrow><mo>(</mo><mi>L</mi><mo>)</mo></mstyle></mrow><annotation>{ displaystyle mathrm {lHash} = mathrm {Hash} (L)}</annotation></semantics></math><img src=$
Générez une chaîne de remplissage PS composée de ${\displaystyle k-\mathrm {mLen} -2\cdot \mathrm {hLen} -2 <semantics><mrow><mstyle><mi>k</mi><mo>−</mo><mrow><mi>m</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>2</mn><mo>⋅</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>2</mn></mstyle></mrow><annotation>{ displaystyle k- mathrm {mLen} -2 cdot mathrm {hLen} -2}</annotation></semantics></math><img src=$
Concaténez lHash , PS , l'octet unique 0x01 et le message M pour former un bloc de données DB : ${\displaystyle \mathrm {DB} =\mathrm {lHash} ||\mathrm {PS} ||\mathrm {0x01} ||\mathrm {M} <semantics><mrow><mstyle><mrow><mi>D</mi><mi>B</mi></mrow><mo>=</mo><mrow><mi>l</mi><mi>H</mi><mi>un</mi><mi>s</mi><mi>h</mi></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>P</mi><mi>S</mi></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mn>0</mn><mi>x</mi><mn>01</mn></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>M</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {DB} =\mathrm {lHash} ||\mathrm {PS} ||\mathrm {0x01} ||\mathrm {M} }</annotation></semantics></math><img src=$ ${\displaystyle k-\mathrm {hLen} -1 <semantics><mrow><mstyle><mi>k</mi><mo>−</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>1</mn></mstyle></mrow><annotation>{ displaystyle k- mathrm {hLen} -1}</annotation></semantics></math><img src=$
Générez une graine aléatoire de longueur hLen .
Utilisez la fonction de génération de masque pour générer un masque de la longueur appropriée pour le bloc de données : ${\displaystyle \mathrm {dbMask} =\mathrm {MGF} (\mathrm {seed} ,k-\mathrm {hLen} -1) <semantics><mrow><mstyle><mrow><mi>d</mi><mi>b</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow><mo>=</mo><mrow><mi>M</mi><mi>G</mi><mi>F</mi></mrow><mo>(</mo><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>,</mo><mi>k</mi><mo>−</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>1</mn><mo>)</mo></mstyle></mrow><annotation>{ displaystyle mathrm {dbMask} = mathrm {MGF} ( mathrm {seed}, k- mathrm {hLen} -1)}</annotation></semantics></math><img src=$
Masquez le bloc de données avec le masque généré : ${\displaystyle \mathrm {maskedDB} =\mathrm {DB} \oplus \mathrm {dbMask} <semantics><mrow><mstyle><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow><mo>=</mo><mrow><mi>D</mi><mi>B</mi></mrow><mo>⊕</mo><mrow><mi>d</mi><mi>b</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {maskedDB} =\mathrm {DB} \oplus \mathrm {dbMask} }</annotation></semantics></math><img src=$
Utilisez la fonction de génération de masque pour générer un masque de longueur hLen pour la graine : ${\displaystyle \mathrm {seedMask} =\mathrm {MGF} (\mathrm {maskedDB} ,\mathrm {hLen} ) <semantics><mrow><mstyle><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow><mo>=</mo><mrow><mi>M</mi><mi>G</mi><mi>F</mi></mrow><mo>(</mo><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow><mo>,</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>)</mo></mstyle></mrow><annotation>{\displaystyle \mathrm {seedMask} =\mathrm {MGF} (\mathrm {maskedDB} ,\mathrm {hLen} )}</annotation></semantics></math><img src=$
Masquez la graine avec le masque généré : ${\displaystyle \mathrm {maskedSeed} =\mathrm {seed} \oplus \mathrm {seedMask} <semantics><mrow><mstyle><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>S</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>=</mo><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>⊕</mo><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {maskedSeed} =\mathrm {seed} \oplus \mathrm {seedMask} }</annotation></semantics></math><img src=$
Le message encodé (rempli) est l'octet 0x00 concaténé avec maskedSeed et maskedDB : ${\displaystyle \mathrm {EM} =\mathrm {0x00} ||\mathrm {maskedSeed} ||\mathrm {maskedDB} <semantics><mrow><mstyle><mrow><mi>E</mi><mi>M</mi></mrow><mo>=</mo><mrow><mn>0</mn><mi>x</mi><mn>00</mn></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>S</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {EM} =\mathrm {0x00} ||\mathrm {maskedSeed} ||\mathrm {maskedDB} }</annotation></semantics></math><img src=$

Décodage

Le décodage fonctionne en inversant les étapes effectuées dans l'algorithme d'encodage :

Hachez l'étiquette L en utilisant la fonction de hachage choisie : ${\displaystyle \mathrm {lHash} =\mathrm {Hash} (L) <semantics><mrow><mstyle><mrow><mi>l</mi><mi>H</mi><mi>un</mi><mi>s</mi><mi>h</mi></mrow><mo>=</mo><mrow><mi>H</mi><mi>un</mi><mi>s</mi><mi>h</mi></mrow><mo>(</mo><mi>L</mi><mo>)</mo></mstyle></mrow><annotation>{\displaystyle \mathrm {lHash} =\mathrm {Hash} (L)}</annotation></semantics></math><img src=$
Pour inverser l'étape 9, divisez le message codé EM en l'octet 0x00, le maskedSeed (de longueur hLen ) et le maskedDB : ${\displaystyle \mathrm {EM} =\mathrm {0x00} ||\mathrm {maskedSeed} ||\mathrm {maskedDB} <semantics><mrow><mstyle><mrow><mi>E</mi><mi>M</mi></mrow><mo>=</mo><mrow><mn>0</mn><mi>x</mi><mn>00</mn></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>S</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mrow><mo>|</mo></mrow><mrow><mo>|</mo></mrow><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {EM} =\mathrm {0x00} ||\mathrm {maskedSeed} ||\mathrm {maskedDB} }</annotation></semantics></math><img src=$
Générez le masque de graine qui a été utilisé pour masquer la graine : ${\displaystyle \mathrm {seedMask} =\mathrm {MGF} (\mathrm {maskedDB} ,\mathrm {hLen} ) <semantics><mrow><mstyle><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow><mo>=</mo><mrow><mi>M</mi><mi>G</mi><mi>F</mi></mrow><mo>(</mo><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow><mo>,</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>)</mo></mstyle></mrow><annotation>{\displaystyle \mathrm {seedMask} =\mathrm {MGF} (\mathrm {maskedDB} ,\mathrm {hLen} )}</annotation></semantics></math><img src=$
Pour annuler l'étape 8, récupérez la graine avec le SeedMask : ${\displaystyle \mathrm {seed} =\mathrm {maskedSeed} \oplus \mathrm {seedMask} <semantics><mrow><mstyle><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>=</mo><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>S</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>⊕</mo><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {seed} =\mathrm {maskedSeed} \oplus \mathrm {seedMask} }</annotation></semantics></math><img src=$
Générez le dbMask qui a été utilisé pour masquer le bloc de données : ${\displaystyle \mathrm {dbMask} =\mathrm {MGF} (\mathrm {seed} ,k-\mathrm {hLen} -1) <semantics><mrow><mstyle><mrow><mi>d</mi><mi>b</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow><mo>=</mo><mrow><mi>M</mi><mi>G</mi><mi>F</mi></mrow><mo>(</mo><mrow><mi>s</mi><mi>e</mi><mi>e</mi><mi>d</mi></mrow><mo>,</mo><mi>k</mi><mo>−</mo><mrow><mi>h</mi><mi>L</mi><mi>e</mi><mi>n</mi></mrow><mo>−</mo><mn>1</mn><mo>)</mo></mstyle></mrow><annotation>{\displaystyle \mathrm {dbMask} =\mathrm {MGF} (\mathrm {seed} ,k-\mathrm {hLen} -1)}</annotation></semantics></math><img src=$
Pour annuler l'étape 6, récupérez le bloc de données DB : ${\displaystyle \mathrm {DB} =\mathrm {maskedDB} \oplus \mathrm {dbMask} <semantics><mrow><mstyle><mrow><mi>D</mi><mi>B</mi></mrow><mo>=</mo><mrow><mi>m</mi><mi>un</mi><mi>s</mi><mi>k</mi><mi>e</mi><mi>d</mi><mi>D</mi><mi>B</mi></mrow><mo>⊕</mo><mrow><mi>d</mi><mi>b</mi><mi>M</mi><mi>un</mi><mi>s</mi><mi>k</mi></mrow></mstyle></mrow><annotation>{\displaystyle \mathrm {DB} =\mathrm {maskedDB} \oplus \mathrm {dbMask} }</annotation></semantics></math><img src=$
Pour inverser l'étape 3, divisez le bloc de données en ses parties :
.
1. Vérifiez que :
  - lHash' est égal au lHash calculé
  - PS ne contient que des octets 0x00
  - PS et M sont séparés par l'octet 0x01 et
  - Le premier octet de EM est l'octet 0x00.
2. Si l'une de ces conditions n'est pas remplie, le remplissage est invalide.

Utilisation avec RSA : Le message encodé peut ensuite être chiffré avec RSA. Le caractère déterministe de RSA est désormais évité grâce à l’utilisation du chiffrement OAEP, car la graine est générée aléatoirement et influence l’intégralité du message encodé.

Sécurité

La sécurité de type « tout ou rien » repose sur le fait que pour récupérer M , il est nécessaire de récupérer l'intégralité de maskedDB et de maskedSeed ; maskedDB est indispensable pour récupérer la graine à partir de maskedSeed , et la graine est indispensable pour récupérer le bloc de données DB à partir de maskedDB . Étant donné que toute modification d'un bit d'un hachage cryptographique modifie complètement le résultat, l'intégralité de maskedDB et de maskedSeed doit être récupérée intégralement.

Mise en œuvre

Dans la norme PKCS#1, les oracles aléatoires sont identiques. La norme PKCS#1 exige en outre que les oracles aléatoires soient de type MGF1 avec une fonction de hachage appropriée.