Algorithme RH (explication de 'c1'

ALGORITHME RH
Création des clefs de session		Chiffrement de 'c1' : 1re partie de 'c'		Chiffrement de 'c2' : 2e partie de 'c'
Explication	Codes	Explication	Codes	Explication	Codes
Explication du chiffrement de 'c1'

'Algorithme RH' : 'RH' pour le nom de son auteur 'Raymond Houle'.
Tous les droits sur cet 'algorithme RH' (en partie ou en totalité et cela à partir
de son développement jusqu'à son achèvement dans la version 3 et+ d'AllCrypter) sont réservés.

Cet algorithme est constitué d'au moins deux parties: la 1re partie (c1) qui contient toutes les données à chiffrer (pouvant contenir une fiche d'information), et la 2e partie (c2) qui contient les 2 clefs de session chiffrées (plus d'autres informations) à partir de la clef personnelle (clef secrète de l'utilisateur).

Voici les étapes pour le chiffrement de 'm' dans le chiffré 1 (c1): le chiffrement de la 1re partie de l'algo RH contient les données (m) à chiffrer et les données d'une fiche d'information personnelle d'AllCrypter (v.3+). Ci dessous, les étapes du chiffrement de 'm' sont détaillées; les mêmes étapes sont valables pour le chiffrement de la fiche d'information (fic); le chiffré de 'fic' est ajouté au bout du chiffré de 'm' pour former 'c1'.

Il est sous-entendu que les 2 clefs de session utilisées pour chiffrer 'm' sont premièrement créées aléatoirement à chaque fois qu'un chiffrement est exécuté, même si 'm' est identique d'un chiffrement à l'autre. Le procédé de création des clefs de session est expliqué dans un autre exposé ainsi que le chiffrement de 'c2'. Donc, ne pas confondre les 2 clefs de session créées automatiquement (et qui sont différentes d'un chiffrement à l'autre) d'avec la clef personnelle que l'utilisateur s'invente (et qu'il peut utiliser plusieurs fois selon son bon plaisir). L'utilisateur n'a pas à s'occuper des 2 clefs de session qu'il n'a pas à connaître, mais il n'a qu'à retenir sa clef personnelle (clef secrète).

  Voici quelques définitions pour aider à comprendre cet exposé:
-   k = clef personnelle et secrète (caractères choisis par l'utilisateur servant au chiffrement des 2 clefs de session finales et d'autres informations). Influence les calculs lors de la génération aléatoire de 'sia' et 'sib', et détermine leur taille.
-   sa = première clef de session complète.
-   sb = deuxième clef de session complète.
-   sia = première clef de session initiale (les premiers caractères de 'sa' générés au hasard; jamais les mêmes). 'sia' est de la même taille que 'k'.
-   sib = deuxième clef de session initiale (les premiers caractères de 'sb' générés au hasard; jamais les mêmes). 'sib' est de la même taille que 'k'.
-   sfa = première clef de session finale (les derniers caractères de 'sa' qui sont conservés pour être chiffrée dans le 2e chiffré (c2) : la 2e partie de 'c'). 'sfa' est de la même taille que 'k'.
-   sfb = deuxième clef de session finale (les derniers caractères de 'sb' qui sont conservés pour être chiffrée dans le 2e chiffré (c2) : la 2e partie de 'c'). 'sfb' est de la même taille que 'k'.
-   m = données à chiffrer de la 1re partie de 'c1'.
-   bro() = fonction qui incrémente et brouille les données.
-   bro(m) = données incrémentées et brouillées.
-   per() = fonction qui permute les données.
-   per(m) = données permutées.
-   per(bro(m)) = données incrémentées/brouillées et permutées.
-   c = données totales chiffrées comprenant c1 et c2.
-   c1 = données chiffré de la 1re partie de 'c' : contient les données de 'm' chiffré et de 'fic' chiffré.
-   c2 = données chiffrées de la 2e partie de 'c' : contient le chiffré de 'sfa', de 'sfb', et d'autres informations spéciales à être utilisées lors du déchiffrement.
-   ca = caractères choisis aléatoirement dont la quantité est déterminée par exemple pour combler un multiple de 4 ou de 8 dans l'ensemble des données à chiffrer.
-   f = fonction produisant 'c'.
-   f1 = fonction produisant 'c1'.
-   f1a = fonction produisant le chiffrement de 'm'.
-   f1b = fonction produisant le chiffrement de 'fic'.
-   f2 = fonction produisant 'c2'.
-   || = et.
-   sa> = caractère de droite de 'sa'; le '>' est valable pour toutes chaînes de caractères: 'sa>', 'sb>', etc.
-   sa_3 = 3e caractère de 'sa'.
-   sa_3> = chiffre de droite du nombre ascii du 3e caractère de 'sa'. Exemple: si 'sa' = "ab25" alors 'sa_3' est 2 dont le nombre ascii est '50'. Donc, 'sa_3>' équivaut à '0' (le chiffre de droite du nombre '50').
-   sa> = dernier caractère (à droite) de 'sa'.
-   sa>+ = caractère qui s'ajoute à la suite du caractère de droite dans 'sa'.
-   sa<+ = caractère qui s'ajoute avant le premier caractère de gauche dans 'sa'.
-   sa_> = même signification que 'sa_3>' à l'exception que le caractère n'est pas définie; on met donc l'accent sur le chiffre de droite du nombre ascii d'un caractère quelconque.
-   sa>> = chiffre de droite du nombre ascii du dernier caractère (à droite) de 'sa'.
-   sa_2<| = signifie qu'il sagit de l'avant dernier caractère de la chaîne de caractères qui se trouve dans 'sa'; le 2e caractère avant la fin de 'sa'.

  Dans son ensemble, l'ago RH peut se définir de différentes façons que voici:
c = c1 || c2
c = c1a || c1b || c2
f() = f1() || f2()
f() = f1a() || f1b() || f2()
c = f(m || fic || InfoS, k)
c1 = xor(cox(bro(inv(m))) || cox(bro(inv(fic))), (sa + sb) mod 256)
c = xor(cox(bro(inv(m))) || cox(bro(inv(fic))), (sa + sb) mod 256) || c2

  Voici, étape par étape, un exemple de chiffrement pour la 1re partie de 'c1', c'est-à-dire 'xor(cox(bro(inv(m))), (sa + sb) mod 256)':
Supposons que nous ayons...
- la clef personnelle suivante:
k = 'abcdefghijklmnop' = 097-098-099-100-101-102-103-104-105-106-107-108-109-110-111-112-

  Parce que 'k' a une taille de 16 caractères alors les 2 clefs de sessions 'sia' et 'sib' sont créées avec une taille de 16 caractères chacune.

- la 1re clef de session initiale suivante:
sia = '0123456789101112' = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-

- la 2e clef de session initiale suivante:
sib = '1314151617181920' = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-

- les caractères de 'm' suivants à chiffrer:
m = 'Message secret' = 077-101-115-115-097-103-101-032-115-101-099-114-101-116-

  Dans toutes les étapes, les caractères de 'k', de 'sia', de 'sib' et de 'm' seront convertis et utilisés en nombre ascii pour question de clarté, puisque autrement certains caractères spéciaux ne pourraient pas s'afficher ici. Donc, se référer à la table des 256 caractères ascii (0 à 255) pour connaître les caractères correspondant à leur nombre ascii.
  À noter aussi que tous les nombres ascii qui dépasseront le nombre 255 peuvent être diminués avec le 'modulo 256'; mais dans cet exposé le 'modulo' sera fait à la fin lors de la dernière étape ou lorsque cela pourrait être nécessaire pour ne pas fausser les données numériques ascii ou pour une meilleure compréhension.

ÉTAPE 1: inversion de chaque caractère de 'm': donc, 'm2 = inv(m)'.

Le dernier caractère devient le 1er, l'avant dernier caractère devient le 2e, etc. Donc,
m = '077-101-115-115-097-103-101-032-115-101-099-114-101-116-'
devient
m2 = '116-101-114-099-101-115-032-101-103-097-115-115-101-077-'

Ainsi, 'm2 = inv(m)'.

ÉTAPE 2: brouillage de chaque caractère ascii de 'm2' par incrémentation, combinaison et addition: donc, 'm3 = bro(m2)'.

  On incrémente (inc) de 'un' chaque caractères de 'm2' puis on additionne d'autres valeurs à 'm2' pour enfin obtenir 'm3'.
  Ceci est pour diversifier d'avantage les futurs caractères ajoutés aux 2 clefs de session dans le cas où 'm' comportait plusieurs caractères ascii zéro de suite (comme c'est le cas pour certains fichiers vidéo).

  Le procédé d'incrémentation débute avec la valeur zéro, ensuite on continue avec 1, puis 2, etc. ; on ajoute 1 de plus à chaque caractère de 'm2' qui suit. Après le nombre 255 on recommence le cycle avec la valeur zéro.
  On procède au brouillage en additionnant le 1er caractère de 'm2', le chiffre de droite du 2e caractère ascii de 'sa' combiné au chiffre de droite du 4e caractère ascii de 'sb', la valeur incrémentale et la valeur ascii du xème caractère de 'sb' dont le chiffre de droite (additionné à 7) du 4e caractère ascii de 'sb' indique (ce chiffre de droite sélectionne un caractère parmi les 10 caractères allant du 7e au 16e caractère de 'sb'; on obtient donc une valeur permutée). Dans notre exemple ci-dessous, les 2 valeurs combinées sont '9' (dans 'sa') et '2' (dans 'sb') produisant ainsi '92'; le caractère de droite de '92' est '2', et on additionne donc 7 à 2 pour obtenir 9 lequel indique le 9e caractère de 'sb'.
  Dans notre exemple, en se servant de notre formule (m3_1 = sa_2>||sb_4> + sb_7~16 + inc_1 + m2_1) on a l'addition suivante: '92 + 49 + 0 + 116' ('combinaison des chiffres de droite de sa et de sb' + 'valeur permutée de sb' + 'valeur incrémentale' + 'm2').

sia     = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-
sa mod 256 = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-116-168-023-045-210-228-169-080-123-066-
sib     = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-
sb mod 256 = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-140-007-067-065-026-079-037-234-043-006-

  On ne garde que le chiffre de droite de chaque nombre ascii de 'sa' et 'sb':
  008-009-000-001-002-003-004-005-006-007-009-008-009-009-009-000-004-002-008-001-... = chiffre de droite des nombres ascii de 'sa mod 256'; (sa_1>, sa_2>, sa_3>, etc.).
  009-001-009-002-009-003-009-004-009-005-009-006-009-007-000-008-000-007-006-000-... = chiffre de droite des nombres ascii de 'sb mod 256'; (sb_1>, sb_2>, sb_3>, etc.).
  092-009-013-029-034-049-055-069-076-099-087-090-098-090-007-046-020-... = combinaison de ces 2 chiffres de droite de 'sa_>' et 'sb_>'.
  On additionne ce résultat aux données 'm2', 'sb_7~16' et 'inc' (valeurs incrémentales):

  092-009-013-029-034-049-055-069-076-099-087-090-098-090- = 'sa_2>||sb_4>', 'sa_3>||sb_5>', etc.
  049-080-056-136-050-140-147-067-140-026-065-147-037-040- = 'sb_7~16'.
  000-001-002-003-004-005-006-007-008-009-010-011-012-013- = 'inc' (valeurs incrémentales).
  116-101-114-099-101-115-032-101-103-097-115-115-101-077- = 'm2'.

  257-191-185-267-189-309-240-244-327-231-277-363-248-220- = 'm3' (total).
  001-191-185-011-189-053-240-244-071-231-021-107-248-220- = 'm3 mod 256' (total).

  Les caractères manquant de 'sa' et 'sb' sont trouvés grâce à l'étape 3 mais ils ont été ajoutés à l'avance ici pour faire plus simple dans le calcul de cette étape 2.
  Donc, pour avoir trouvé ces quelques caractères manquant de 'sa' et 'sb', nous devrons, à l'étape 3, prolonger les 2 clefs de sessions 'sa' et 'sb' pour ensuite pouvoir continuer le calcul de cette étape-ci.
  Dans la procédure normale, à cet étape 2, on 'brouille' la 1re colonne, ensuite (via l'étape 3) on prolonge d'un caractère les 2 clefs de sessions 'sa' et 'sb', puis (à cet étape 2) on 'brouille' la 2e colonne, ensuite (à l'étape 3) on prolonge d'un autre caractère les 2 clefs de sessions 'sa' et 'sb', et ainsi de suite jusqu'au dernier caractère de 'm2'.
  On doit donc prolonger les 2 clefs de sessions 'sa' et 'sb' pour pouvoir continuer le brouillage de 'm2' au complet. Lorsque 'm2' est 'brouillé' alors cela produit 'm3'; donc 'm3 = bro(m2)' ou 'm3 = bro(inv(m))'.

ÉTAPE 3: prolongement des 2 clefs de session 'sia' et 'sib': 'pro(sia||sib)'; donc, 'sa = pro(sia)' et 'sb = pro(sib)'.

  Les 2 clefs de session 'sa' et 'sb' doivent avoir une taille supérieure à celle de 'm', c'est-à-dire que la taille qui excède doit être équivalente à celle de 'k'. Ces caractères qui excèdent dans 'sa' et 'sb' correspondent à la taille de 'sfa' et 'sfb'. Donc, 'sia' et 'sib', 'k', 'sfa' et 'sfb' ont toujours la même taille, toujours le même nombre de caractères.

  Voici la formule pour prolonger 'sia' et 'sib' sous l'influence de 'm3':
'((sa_1 + sa_7) xor (sa_13 + m3_1)) mod 256 = sa>+' (dernier octet ajouté à 'sa').
'((sb_1 + sb_3) xor (sb_5 + m3_1) ) mod 256 = sb>+' (dernier octet ajouté à 'sb').

  Donc pour 'sa', la somme des 1er et 7e caractères de la clef 'sa' est ixorée avec la somme des 13e caractère de la clef 'sa' et du 1er caractère de 'm3'; on fait de même avec le caractère suivant, et ainsi de suite jusqu'au dernier caractère de 'm3'.
  Pour 'sb', la somme des 1er et 3e caractères de la clef 'sb' est ixorée avec la somme des 5e caractère de la clef 'sb' et du 1er caractère de 'm3'; on fait de même avec le caractère suivant, et ainsi de suite jusqu'au dernier caractère de 'm3'.
  La création (le prolongement) de 'sa' et 'sb' est donc INFLUENCÉE par 'm3'.

  Voici ici les données nécessaires qui ont été utilisées à l'étape 2. Nous continuons à les utiliser à cette étape 3:
sia = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-
sib = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-
m3 = 001-191-185-011-189-053-240-244-071-231-021-107-248-220-

(048 + 054) xor (049 + 001) = 084
  sa = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-
(049 + 049) xor (049 + 001) = 080
  sb = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-

(049 + 055) xor (049 + 191) = 152
  sa = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-
(051 + 052) xor (053 + 191) = 147
  sb = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-

(050 + 056) xor (049 + 185) = 128
  sa = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-
(049 + 049) xor (049 + 185) = 136
  sb = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-

(051 + 057) xor (050 + 011) = 081
  sa = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-
(052 + 053) xor (054 + 011) = 040
  sb = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-

(052 + 049) xor (084 + 189) = 116
  sa = 048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-116-...
(049 + 049) xor (049 + 189) = 140
  sb = 049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-140-...

  On continue les calculs pour le prolongement de 'sa' et 'sb' jusqu'au dernier caractère de 'm3'.
  On a maintenant les caractères manquant de 'sa' et de 'sb' afin de trouver les autres caractères de 'm3'. Ainsi, le calcul de 'm3' complété, on obtient:
001-191-185-011-189-053-240-244-071-231-021-107-248-220- = 'm3 mod 256'.

  Lorsque les calculs de cette étape 3 sont terminés,
  'sa mod 256' devient:
048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-116-168-023-045-210-228-169-080-123-066-

  et 'sb mod 256' devient:
049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-140-007-067-065-026-079-037-234-043-006-

  Ainsi, 'sia' est:
048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-

  et 'sib' est:
049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-

  'sfa mod 256' à ce stade est:
049-050-084-152-128-081-116-168-023-045-210-228-169-080-123-066-

  et 'sfb mod 256' à ce stade est:
050-048-080-147-136-040-140-007-067-065-026-079-037-234-043-006-

ÉTAPE 4: Ixoration de 'm3' avec le chiffre de droite du 10e caractère ascii de 'sa' combiné au chiffre de droite du 2e caractère ascii de 'sb', produisant ainsi 'm4': 'm4 = cox(bro(inv(m)))' ou 'm4 = cox(m3)'.
'cox' pour 'co' et 'x'; 'co' signifiant 'combinaison' (2 chiffres combinés de 'sa_10' et 'sb_2'), et 'x' signifiant 'xor'.
  Donc, 'm4_1 = ((sa_10> || sb_2>) xor m3_1) mod 256':

'sa mod 256' = '048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-116-168-023-045-210-228-169-080-123-066-'

'sb mod 256' = '049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-140-007-067-065-026-079-037-234-043-006-'
'm3'       = '001-191-185-011-189-053-240-244-071-231-021-107-248-220-'

  Dans notre exemple ici, on joint le chiffre de droite (7) du nombre ascii du 10e caractère de 'sa' ('057' dans notre exemple) et le chiffre de droite (1) du nombre ascii du 2e caractère de 'sb' ('051' dans notre exemple). On ixore le résultat de la combinaison ('71' dans notre exemple) avec le 1er caractère de 'm3' ('001' dans notre exemple), et le caractère qui en résulte (ascii '070') devient le 1er caractère de 'm4': donc, '71' xor '001' = 070 .

On poursuit en joignant le chiffre de droite (9) du nombre ascii du 11e caractère de 'sa' ('049' dans notre exemple) et le chiffre de droite (9) du nombre ascii du 3e caractère de 'sb' ('049' dans notre exemple). On ixore le résultat de la combinaison ('99' dans notre exemple) avec le 2e caractère de 'm3' ('191' dans notre exemple), et le caractère qui en résulte ('220') devient le 2e caractère de 'm4': donc, '99' xor '191' = 220 .

On continue ainsi jusqu'au dernier caractère (220) de 'm3', et le résultat final devient 'm4'.

Voici 'm4' produit à partir de 'm3':
'm4' = '070-220-235-104-224-086-244-197-094-190-005-046-175-194-'

ÉTAPE 5: Ixoration finale de 'm4' avec la somme des 2 clefs de session 'sa' et 'sb' produisant 'm5':
'm5 = xor(cox(bro(inv(m))), (sa + sb) mod 256)' ou
'm5 = xor(m4, (sa + sb) mod 256)' .

  Dans cette dernière étape du chiffrement de la première partie de 'c1' (donc, de 'c1a'), dans notre exemple, on additionne le 17e caractère de 'sa' avec le 6e caractère de 'sb', puis on ixore ce résultat avec le 1er caractère de 'm4'; puis avec ce résultat, on fait un 'modulo 256' pour s'assurer de demeurer dans une plage ascii de 256 (donc, de 0 à 255). On a donc un décalage de 17 caractères et un autre de 6 caractères dans le calcul entre les 2 caractères des 2 clefs de session et celui de 'm4'.
  On définit le calcul du 1er caractère ainsi: 'm5_1 = ((sa_17 + sb_6) xor m4_1) mod 256'.

'sa mod 256' = '048-049-050-051-052-053-054-055-056-057-049-048-049-049-049-050-084-152-128-081-116-168-023-045-210-228-169-080-123-066-'

'sb mod 256' = '049-051-049-052-049-053-049-054-049-055-049-056-049-057-050-048-080-147-136-040-140-007-067-065-026-079-037-234-043-006-'
'm4' = '070-220-235-104-224-086-244-197-094-190-005-046-175-194-'

  Donc, '((sa_17 + sb_6) xor m4_1) mod 256 = m5_1':

((084 + 053) xor 070) mod 256 = 207
((152 + 049) xor 220) mod 256 = 021
  ...ainsi de suite jusqu'au dernier caractère de 'm4'.

  On obtient donc comme résultat le chiffré suivant de la 1re partie de 'c1' :
'm5' = '207-021-093-234-075-143-187-155-085-168-220-142-161-008-'

  On aurait pu fusionner les étapes 4 et 5 en utilisant la formule de calcul suivante: 'm4_1 = ((sa_10> || sb_2>) xor (sa_17 + sb_6) xor m3_1) mod 256' .

  Pour chiffrer la 2e partie ('fic') de 'c1' (donc 'c1b'), on procède de la même façon que toutes ces 5 étapes ci-dessus, puis on joint cette 2e partie de 'c1' ('c1b') à la suite de cette 1re partie de 'c1' ('c1a'). Les 2 clefs de session finales de la 1re partie de 'c1' ('c1a') sont les 2 clefs de session initiales servant au chiffrement de la 2e partie de 'c1' ('c1b'; 'fic': la fiche d'information).
  Les 2 clefs de session finales de la 2e partie de 'c1' (donc 'c1b') (et d'autres informations nécessaires) sont chiffrées via la clef personnelle ('k') de l'utilisateur, ce qui produit ainsi 'c2' qu'on joint à la suite de 'c1'. Cliquez ici pour l'explication des étapes du chiffrement de 'c2', sachant que 'c1' et 'c2' forment 'c'.

Donc, ce qui est connu du public est seulement le chiffré (cryptogramme) ainsi que l'algo RH servant à la création du cryptogramme. 'k' doit comporter un minimum de 16 caractères, et les 2 clefs de session ne sont utilisées qu'une seule fois, même si on chiffre les mêmes données plus d'une fois. Le but de cet 'algo RH' étant que personne ne puisse déchiffrer (décrypter) un cryptogramme sans la clef personnelle (k) secrète de l'utilisateur, même en faisant connaître publiquement l'algorithme utilisé ou en exerçant en dehors de l'attaque à force brute les différentes attaques dont les cryptanalystes se servent.

C'est un système à clefs de session jetables automatiquement (faisant penser à celui de Vernam '1917'). Les 2 clefs de session ('sa' et 'sb') générées automatiquement sans que l'utilisateur s'en occupe ne sont donc jamais utilisées 2 fois, mais la clef secrète personnelle (k) de l'utilisateur peut être utilisée autant de fois que désiré.