243 lines
5.2 KiB
Text
243 lines
5.2 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 exdecuter ```sh make run test=<TEST> eve=<ARGS_EVE>```
|
||
en prennant 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^emes,
|
||
et modifient le message et le tag de manière à ce que bob vérifie le mac tag
|
||
le message correctement. Si aucun argument de eve n'est spécifié, eve ne fait
|
||
rien.
|
||
|
||
== Eve ne fait rien : traces d'éxé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érifira le message, il verra donc 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 cross {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 aliéatoire, car la fonction $F_k$ forme une
|
||
bijection sur ${0,1}^n$:
|
||
|
||
* surjectice:
|
||
$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 cross {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.
|