289 lines
6.5 KiB
Text
289 lines
6.5 KiB
Text
#import "@preview/algo:0.3.2": algo, i, d, comment, code
|
||
|
||
#set page(
|
||
numbering: "1 / 1",
|
||
header: [
|
||
#set text(8pt)
|
||
_IFT436, Devoir 1 #h(1fr) Paulin Violette, 2023_
|
||
],
|
||
)
|
||
|
||
#let title(content) = {
|
||
pagebreak(weak:true)
|
||
set text(size:15pt)
|
||
set align(center)
|
||
v(10pt)
|
||
[#content]
|
||
v(10pt)
|
||
}
|
||
|
||
#title[= Devoir 1]
|
||
|
||
#line(length: 100%)
|
||
|
||
#v(70pt)
|
||
|
||
#line(length: 100%)
|
||
|
||
#set par(
|
||
first-line-indent: 1em,
|
||
justify: true,
|
||
)
|
||
= Notes
|
||
Le code présenté est retrouvable sur #link("ssh://sherbrooke@bigblase.xyz:/srv/git/crypto2")\
|
||
mot de passe : `FDS8EbKiDNoJh2QN`\
|
||
Le code a été testé sous linux, kernel 6.5 et librairie à jour (sept 2023), en
|
||
utilisant gcc 13.2.1.
|
||
Pour compiler, il faut d'abord créer le dossier _build_ à la racine du projet.
|
||
Pour tester, il faut faire ```sh make run test=<TEST> eve=<ARGS_EVE>```.
|
||
Il _devrait_ être portable (C99, POSIX compliant)
|
||
#set heading(numbering: "I) a) i)")
|
||
|
||
= Mac insécure
|
||
Pour tester le code, il faut exécuter ```sh make run test=<TEST> eve=<ARGS_EVE>```
|
||
en prenant pour `test`: `ZERO`, `MID`, `MAX`, ou `NAME` (ce qui correspond à un
|
||
message de `0x00000000`, `0x0000ffff`, `0xffffffff`, et `0x626f62` (qui est
|
||
"bob\0" en ASCII) respectivement). Les arguments de `eve` sont les mêmes,
|
||
et modifient le message et le tag de manière à ce que bob vérifie le mac tag
|
||
le message correctement. Si aucun argument d'Eve n'est spécifié, Eve ne fait
|
||
rien.
|
||
|
||
== Eve ne fait rien : traces d'exécutions
|
||
===
|
||
```test=ZERO:
|
||
--- MSG ---
|
||
as 0x: 0
|
||
as char *:
|
||
as uint32: 0
|
||
--- TAG ---
|
||
-2018659035
|
||
--- VERIF ---
|
||
1
|
||
|
||
--- ALICE ---
|
||
sends msg: 0
|
||
sends tag: 2276308261
|
||
knows key: 2276308261
|
||
|
||
--- EVE ---
|
||
recieves msg: 0
|
||
recieves tag: 2276308261
|
||
sends msg: 0
|
||
sends tag: 2276308261
|
||
|
||
--- BOB ---
|
||
recieves msg: 0
|
||
recieves tag: 2276308261
|
||
knows key: 2276308261
|
||
verifies: TRUE
|
||
msg as char *:
|
||
```
|
||
===
|
||
```test=MID:
|
||
--- MSG ---
|
||
as 0x: ffff
|
||
as char *: <20><>
|
||
as uint32: 65535
|
||
--- TAG ---
|
||
1569545002
|
||
--- VERIF ---
|
||
1
|
||
|
||
--- ALICE ---
|
||
sends msg: 65535
|
||
sends tag: 1569545002
|
||
knows key: 1569563861
|
||
|
||
--- EVE ---
|
||
recieves msg: 65535
|
||
recieves tag: 1569545002
|
||
sends msg: 65535
|
||
sends tag: 1569545002
|
||
|
||
--- BOB ---
|
||
recieves msg: 65535
|
||
recieves tag: 1569545002
|
||
knows key: 1569563861
|
||
verifies: TRUE
|
||
msg as char *: <20><>
|
||
```
|
||
|
||
===
|
||
```test=MAX:
|
||
--- MSG ---
|
||
as 0x: ffffffff
|
||
as char *: <20><><EFBFBD><EFBFBD>
|
||
as uint32: 4294967295
|
||
--- TAG ---
|
||
-1254613608
|
||
--- VERIF ---
|
||
1
|
||
|
||
--- ALICE ---
|
||
sends msg: 4294967295
|
||
sends tag: 3040353688
|
||
knows key: 1254613607
|
||
|
||
--- EVE ---
|
||
recieves msg: 4294967295
|
||
recieves tag: 3040353688
|
||
sends msg: 4294967295
|
||
sends tag: 3040353688
|
||
|
||
--- BOB ---
|
||
recieves msg: 4294967295
|
||
recieves tag: 3040353688
|
||
knows key: 1254613607
|
||
verifies: TRUE
|
||
msg as char *: <20><><EFBFBD><EFBFBD>
|
||
```
|
||
|
||
On voit donc que Bob peut vérifier le message, mais pas Eve.
|
||
Ici, le tag est $t$, la clef key est $k$, le message est $m$,
|
||
et _verifies_ est $v$.
|
||
|
||
== Eve modifie le message et le tag
|
||
En faisant tourner n'importe quel test avec un paramètre d'Eve, on voit
|
||
que le MAC est toujours vérifié pour Bob:
|
||
===
|
||
```test=MAX eve=ZERO
|
||
--- MSG ---
|
||
as 0x: ffffffff
|
||
as char *: <20><><EFBFBD><EFBFBD>
|
||
as uint32: 4294967295
|
||
--- TAG ---
|
||
1782958865
|
||
--- VERIF ---
|
||
1
|
||
|
||
--- ALICE ---
|
||
sends msg: 4294967295
|
||
sends tag: 1782958865
|
||
knows key: 2512008430
|
||
|
||
--- EVE ---
|
||
recieves msg: 4294967295
|
||
recieves tag: 1782958865
|
||
sends msg: 0
|
||
sends tag: 2512008430
|
||
|
||
--- BOB ---
|
||
recieves msg: 0
|
||
recieves tag: 2512008430
|
||
knows key: 2512008430
|
||
verifies: TRUE
|
||
msg as char *:
|
||
```
|
||
===
|
||
|
||
```test=ZERO eve=NAME
|
||
--- MSG ---
|
||
as 0x: 0
|
||
as char *:
|
||
as uint32: 0
|
||
--- TAG ---
|
||
-2111190321
|
||
--- VERIF ---
|
||
1
|
||
|
||
--- ALICE ---
|
||
sends msg: 0
|
||
sends tag: 2183776975
|
||
knows key: 2183776975
|
||
|
||
--- EVE ---
|
||
recieves msg: 0
|
||
recieves tag: 2183776975
|
||
sends msg: 6649445
|
||
sends tag: 2186067114
|
||
|
||
--- BOB ---
|
||
recieves msg: 6649445
|
||
recieves tag: 2186067114
|
||
knows key: 2183776975
|
||
verifies: TRUE
|
||
msg as char *: eve
|
||
```
|
||
Ainsi, Eve peut intercepter et envoyer un tag qui semble correct à Bob, peu
|
||
importe le message reçu. On peut faire cela car :
|
||
$t = m xor k$, et Eve connait $t, m$.
|
||
Ainsi, le tag $t'$ est correct aux yeux de Bob, où
|
||
$t' = m xor m xor k = m xor "mac"$.
|
||
Donc, en introduisant le message $m_e$ de Eve, on a:
|
||
$t_e &= m_e xor t xor m \
|
||
&= m_e xor m xor k xor m \
|
||
&= m_e xor k$
|
||
|
||
Quand Bob vérifiera le message, il verra alors un message correctement taggé.
|
||
|
||
Eve peut donc envoyer n'importe quel message traffiqué et vérifiable avec
|
||
une probabilité de 1, du moment que le message et le tag qu'elle reçoit
|
||
sont vérifiables.
|
||
|
||
== Pseudo-aléatoire
|
||
Soit $F: {0,1}^n times {0,1}^n -> {0,1}^n$ telle que $F(k, x) = x xor k$.
|
||
En fixant $k in {0,1}^n$, on peut écrire $F(k, .): {0,1}^n -> {0,1}^n$.
|
||
Cette fonction est pseudo aléatoire, car la fonction $F_k$ forme une
|
||
bijection sur ${0,1}^n$:
|
||
|
||
* Surjective:
|
||
$forall x in {0,1}^n, exists y in {0,1}^n | x xor k = y$
|
||
C'est évident : il suffit de prendre $y = x xor k$, qui existe
|
||
car $xor$ est définit sur ${0,1}^n times {0,1}^n$ et à valeurs dans ${0,1}^n$
|
||
* injective :
|
||
$forall x, y in {0,1}^n, & F_k(x) &= F_k(y) => x = y$
|
||
Supposons qu'on a ces $x,y$. On a alors :
|
||
$x xor k &= y xor k\
|
||
<=> x xor k xor k &= y xor k xor k\
|
||
<=> x &= y $ On a donc ce que l'on voulait.
|
||
|
||
Ainsi, la sortie de $F_k$ est uniformément répartie sur ${0,1}^n$.
|
||
Elle est donc pseudo aléatoire, car elle donne une sortie autant répartie que
|
||
son entrée.
|
||
|
||
= RSA
|
||
Soit la sortie $(143, 11, 13)$ d’un algorithme *GenModulus*($1111$) pour RSA.
|
||
|
||
== $N, P,$ et $q$
|
||
Ici, $N = 143, p = 11, q = 13$. On remarque que $N = p dot q$
|
||
|
||
== $Phi(N)$
|
||
Ici, $Phi(N) = |bb(Z)^*_N| = |bb(Z)/(N bb(Z))| = Phi(p q) = (p-1)(q-1) = 120$
|
||
|
||
La quatrième égalité est valable, car $p$ et $q$ sont premiers.
|
||
|
||
== Exposant inverse
|
||
On pose $e = 7$. On cherche $d = e^-1$ dans $Z^*_N$.
|
||
$
|
||
d = 1 ; d dot e eq.triple 7 [120] \
|
||
d = 2 ; d dot e eq.triple 14 [120] \
|
||
d = 3 ; d dot e eq.triple 21 [120] \
|
||
... \
|
||
d = 99 ; d dot e .eq.triple 93 [120] \
|
||
d = 100 ; d dot e .eq.triple 100 [120] \
|
||
d = 101 ; d dot e .eq.triple 107 [120] \
|
||
d = 102 ; d dot e .eq.triple 114 [120] \
|
||
d = 103 ; d dot e .eq.triple 1 [120] \
|
||
$
|
||
|
||
On voit que $d = 103 eq.triple e^(-1) [N]$ convient.
|
||
|
||
== RSA
|
||
La clef public est donc le couple $k_(italic("pub") = (7, 143) = (e, N)$,
|
||
et la clef privée est le couple $k_(italic("priv") = (103, 143) = (d, N)$
|
||
Pour chiffrer un message $m$, on peut faire $c = m^e % N$, et pour le
|
||
déchiffrer, $m = c^d % N$.
|
||
|
||
Exemple :
|
||
|
||
`
|
||
n = 143
|
||
e = 7
|
||
d = 103
|
||
Public key: (7, 143)
|
||
Private key: (103, 143)
|
||
Original message: 42
|
||
Encrypted message: 81
|
||
Decrypted message: 42
|
||
`
|