crypto2/main.typ

#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
`