violette/crypto3
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

oopsies 1hr late

Browse source
This commit is contained in:
theBigBlase 2023-10-25 01:02:29 -04:00
commit aabd8ae432
4 changed files with 524 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
Makefile Normal file
View file

@ -0,0 +1,30 @@
.PHONY: all test clean build
SRC = src/main.c
OJB = $(SRC:.c=.o)
OUT = build
CC = /usr/bin/gcc
CFLAGS = -ansi -Wall -std=c99 -O0
CFDEBUG = -ansi -Wall -fsanitize=address -g -std=c99
RM = /bin/rm -fr
TEST_F = -D TEST_TECH
TEST = -D TEST_
PART = -D PART_
EVE = -D EVE_
M = -D M
%.o: %.c
$(CC) -c $(CFLAGS)
build:
$(CC) $(SRC) $(PART)$(part) $(EVE)$(eve) $(CFLAGS) -o $(OUT)/main.o
run:
$(CC) $(SRC) $(PART)$(part) $(EVE)$(eve) $(CFDEBUG) -o $(OUT)/main.o && ./build/main.o
clean:
$(RM) $(OBJ) $(OUT)/main.o
run:
$(CC) $(SRC) $(PART)$(part) $(EVE)$(eve) $(CFLAGS) -o $(OUT)/main.o && ./build/main.o $(m)

0
build/.gitkeep Normal file
View file

303
main.typ Normal file
View file

@ -0,0 +1,303 @@
#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 code = rect.with(
inset: 8pt,
fill: rgb("e4e5fa"),
width: 100%,
radius: 6pt
)
#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 part=<PART_NUMBER> eve=<ARGS_EVE>```.
Il _devrait_ être portable (C99, POSIX compliant)
#set heading(numbering: "I) a) i)")
= Diffie Hellman
On implémente les fonctions demandées. Ceci nous donne :
#code[```c
#define MOD2POW63(n) ((n) % UINT64_MAX)
static inline uint32_t
gen()
{
/* rand is between 0 and UINT32_MAX - 1 / 2 (because sign) */
return rand() + rand() + (rand() % 1);
}
```
```c
int
main(int argc, char *argv[])
{
srand(time(0)); /* init rand */
uint32_t key_alice = gen();
uint32_t key_bob = gen();
uint64_t h_a = MOD2POW63(ipow(3, key_alice));
uint64_t h_b = MOD2POW63(ipow(3, key_bob));
printf("Alice generated key %d, sent h_a=%lu\n", key_alice, h_a);
printf("Bob generated key %d, sent h_b=%lu\n", key_bob, h_b);
#ifdef EVE_INTERCEPT
printf("Eve intercepted h_b and h_a.\n");
uint32_t key_eve = gen();
uint64_t h_e = MOD2POW63(ipow(3, key_eve));
printf("Eve generated key %d. She sends h_a to Bob, and h_b to Alice.\n",
key_eve);
uint64_t k_e_a = MOD2POW63(ipow(h_a, key_eve));
uint64_t k_e_b = MOD2POW63(ipow(h_b, key_eve));
printf("Eve comptued k_e_a=%lu, k_e_b=%lu\n", k_e_a, k_e_b);
printf("Eve sends h_e to Bob and Alice\n");
h_a = h_e;
h_b = h_e;
#endif
uint64_t k_a = MOD2POW63(ipow(h_b, key_alice));
uint64_t k_b = MOD2POW63(ipow(h_a, key_bob));
printf("Alice computed k_a=%lu\n", k_a);
printf("Bob computed k_b=%lu\n", k_b);
...
return 0;
}
```]
Pour pouvoir avoir une exponentiation rapide sur les entier, je l'ai
#strike[trouvée sur stackoverflow] implémentée. Je laisse aussi
l'exponentiation modulaire qui sera utile pour la partie 2:
#code[
```c
/* https://stackoverflow.com/a/101613/13156585 */
static uint64_t
ipow(uint32_t base, uint32_t exp)
{
int result = 1;
for (;;)
{
if (exp & 1)
result *= base;
exp >>= 1;
if (!exp)
break;
base *= base;
}
return result;
}
static uint64_t
ipow_mod(uint32_t base, uint32_t exponent, uint32_t mod) {
uint64_t x = 1;
uint64_t y = base;
while (exponent > 0) {
if (exponent % 2 == 1)
x = (x * y) % mod;
y = (y * y) % mod;
exponent = exponent / 2;
}
return (x % mod);
}
```]
==
On a ici $(Pi_(A)^i, Pi_(B)^i) = "DHKEP" ; i=32$
==
On fait tourner une fois sans qu'Eve n'intervienne.
#code[`Alice generated key -1792100893, sent h_a=18446744073108443291
Bob generated key -1044643954, sent h_b=18446744072800391545
Alice computed k_a=1639053353
Bob computed k_b=1639053353
Bob and Alice key match
`]
Eve voit passer $h_b$ et $h_a$.
Cette fois, Eve intervient, et intercepte $h_b$ et $h_a$ (ils ne seront donc
pas déliverés).
On obtient :
#code[`Alice generated key -2077545126, sent h_a=2145716457
Bob generated key 1787548291, sent h_b=18446744071694128667
Eve intercepted h_b and h_a.
Eve generated key -1461028833. She sends h_a to Bob, and h_b to Alice.
Eve comptued k_e_a=18446744073569067097, k_e_b=18446744073273089683
Eve sends h_e_b to Bob and h_e_a to Alice
Alice computed k_a=18446744073569067097
Bob computed k_b=18446744073273089683
Bob and Alice keys match with Eve's!
`]
On note qu'a chaque envoie d'Alice ou Bob, Eve reçoit les messages, et choisis
ou non de les faires passer, et chaque message qu'Alice ou Bob reçoivent
provient donc de Eve.
==
Alice et Bob ne voit aucune différence, si ce n'est un temps entre les
messages plus important. En dehors de cela, il n'y veront aucune différence.
==
On voit pourtant que $k_b != k_a$ quand Eve manipule les hash. Cependant,
comme Alice et Bob ne partagent pas leurs clef privées, il ne le verront pas.
= Chiffrement RSA
C'est les mêmes nombres que dans l'exercice de la semaine dernière. On a donc:
$N = 143, p = 11, q = 13, e = 7, d = 103$
==
#code[```c
static uint32_t
E1(char message, uint32_t key_priv, uint32_t n){
return ipow_mod(message, key_priv, n);
}
static uint32_t
D1(char cypher, uint32_t key_pub, uint32_t n){
return ipow_mod(cypher, key_pub, n);
}
```]
Pour tester, j'ai il faudra aussi passer la valeur du message au moment
d'exécuter le programme:`make run part=2 m=5`.
Lignes utils : #code[```c
int
main(int argc, char *argv[])
{
...
uint32_t e1 = E1(atoi(argv[1]), e, n);
uint32_t d1 = D1(e1, d, n);
printf("m: %d, cypher: %u, decrypt: %u\n", atoi(argv[1]), e1, d1);
return 0;
}
```]
On obtient :
#table(
columns: (1fr, 1fr, 1fr),
inset: 10pt,
align: center,
[`m: 3, cypher: 42, decrypt: 3`],
[`m: 5, cypher: 47, decrypt: 5`],
[`m: 7, cypher: 6, decrypt: 7`]
)
On remarque qu'à chaque fois, on a bien $m = d$, ce qui montre que le message
d'origine est bien celui déchiffré.
La clef privée est le couple $(d, N)$, la clef publique le couple $(e, N)$.
Ainsi, Alice dispose de $(d, e, N)$, et Bob de $(d, N)$. Alice connait aussi
$p, q$ permettant de générer $N$.
Si Alice transmet la clef privée "Willy Nilly" à Bob,
alors Eve peut intercepter $(N, d)$. Ainsi, elle pourrait
déchiffrer les messages de Alice chiffré par cette clef, tout comme Bob.
==
#table(
columns: (1fr, 1fr),
inset: 10pt,
align: center,
[`m: 0, cypher: 0, decrypt: 0`],
[`m: 1, cypher: 1, decrypt: 1`]
)
On remarque que $forall x in bb(N)^* 0^x eq.triple 0 [N]$, et que
$forall x in bb(N)^* 1^x eq.triple 1 [N]$. Pas de surprise dans le résultat.
Eve peut donc deviner le message pour $m=0, m=1$, même sans connaitre les clefs.
== Signatures RSA
On fait comme avant, mais on utilise la clef privée pour signer, et la clef
publique pour vérifier.
On fait alors les fonctions suivantes :
#code[```c
inline static uint32_t
Sign2(char message, uint32_t key_priv, uint32_t n){
return E1(message, key_priv, n);
}
inline static uint32_t
Verif2(char signature, uint32_t key_pub, uint32_t n){
return D1(signature, key_pub, n);
}
```]
#highlight(fill:rgb("e4e5ea"))[Notes : en `inline`-ant la fonction, on ne fait aucun appel supplémentaire,
on peut le voir comme un alias aux fonctions précédentes :)]
Si le message était plus compliqué, (ex : string) on pourrait alors faire
la signature sur le hash du message. On le fait pas ici.
#table(
columns: (1fr, 1fr, 1fr),
inset: 10pt,
align: center,
[`m: 3, sign: 16, verif: 3`],
[`m: 5, sign: 125, verif: 5`],
[`m: 7, sign: 123, verif: 7`]
)
Où $italic("sk") = (d, N) = (103, 143), italic("pk") = (e, N) = (7, 143)$
Eve voit passer _pk_, le message et la signature.
Elle peut donc vérifier l'origine du message, mais ne peut pas reproduire de
message avec une signature qui serait cohérente avec ses clef.
Elle pourrait essayer de recomposer une clef privée qui convient.
Elle connait $N$. Il faut qu'elle trouve une décomposition de $N$ en nombre
premiers, avec seuelement deux composantes premières.
Or, une décomposition en nombre premier est en temps #link("https://en.wikipedia.org/wiki/Integer_factorization#Difficulty_and_complexity")[#text(blue)[#underline[subexponentiel]]],
et non polynomial.
Eve ne peut donc pas reconstruire de clef privée pour resigner un message.
Elle devra utiliser une autre stratégie. Par exemple, elle pourrait essayer
de regenerer une clef publique chez Bob dont elle maitrise la clef publique.

191
src/main.c Normal file
View file

@ -0,0 +1,191 @@
/*
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <paum1202@usherbrooke.ca> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. -violette paulin
* ----------------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define MOD2POW63(n) ((n) % UINT64_MAX)
#define SIZE_KEY 32
static inline uint32_t gen();
static inline uint32_t E1(char, uint32_t, uint32_t);
static inline uint32_t D1(char, uint32_t, uint32_t);
static inline uint32_t Sign2(char, uint32_t, uint32_t);
static inline uint32_t Verif2(char, uint32_t, uint32_t);
static inline uint64_t ipow(uint32_t, uint32_t);
static inline uint64_t ipow_mod(uint32_t, uint32_t, uint32_t);
int
main(int argc, char *argv[])
{
srand(time(0)); /* init rand */
#ifdef PART_1
uint32_t key_alice = gen();
uint32_t key_bob = gen();
uint64_t h_a = MOD2POW63(ipow(3, key_alice));
uint64_t h_b = MOD2POW63(ipow(3, key_bob));
printf("Alice generated key %d, sent h_a=%lu\n", key_alice, h_a);
printf("Bob generated key %d, sent h_b=%lu\n", key_bob, h_b);
#ifdef EVE_INTERCEPT
printf("Eve intercepted h_b and h_a.\n");
uint32_t key_eve = gen();
uint64_t h_e = MOD2POW63(ipow(3, key_eve));
printf("Eve generated key %d. She sends h_a to Bob, and h_b to Alice.\n",
key_eve);
uint64_t k_e_a = MOD2POW63(ipow(h_a, key_eve));
uint64_t k_e_b = MOD2POW63(ipow(h_b, key_eve));
printf("Eve comptued k_e_a=%lu, k_e_b=%lu\n", k_e_a, k_e_b);
printf("Eve sends h_e_b to Bob and h_e_a to Alice\n");
h_a = h_e;
h_b = h_e;
#endif
uint64_t k_a = MOD2POW63(ipow(h_b, key_alice));
uint64_t k_b = MOD2POW63(ipow(h_a, key_bob));
printf("Alice computed k_a=%lu\n", k_a);
printf("Bob computed k_b=%lu\n", k_b);
#ifdef EVE_INTERCEPT
if (k_e_a != k_a) {
printf("k_e_a != k_a\n");
exit(-1);
}
else if (k_e_b != k_b) {
printf("k_e_b != k_b\n");
exit(-1);
}
else {
printf("Bob and Alice keys match with Eve's!\n");
}
#else
if (k_a != k_b) {
printf("k_a != k_b\n");
exit(-1);
}
else {
printf("Bob and Alice key match\n");
}
#endif
#endif
#ifdef PART_2
uint32_t p = 13;
uint32_t q = 11;
uint32_t n = p * q;
uint32_t e = 7;
uint32_t d = 103; /* as computed in last weeks' assignement,
cant be bothered to implement modular invert rn,
im doing this whole assignement w/ only 2 hours :)
who tf gives assignement during breaks ??
therefore i forgor */
uint32_t e1 = E1(atoi(argv[1]), e, n);
uint32_t d1 = D1(e1, d, n);
printf("m: %d, cypher: %u, decrypt: %u\n", atoi(argv[1]), e1, d1);
#endif
#ifdef PART_3
uint32_t p = 13;
uint32_t q = 11;
uint32_t n = p * q;
uint32_t e = 7;
uint32_t d = 103; /* same thing but we reverse priv and pub key
and give it shinny new name so you think it's different
:) */
uint32_t signature = Sign2(atoi(argv[1]), d, n);
uint32_t verif = Verif2(signature, e, n);
printf("m: %d, signature: %u, verif: %u\n", atoi(argv[1]), signature, verif);
#endif
return 0;
}
static inline uint32_t
gen()
{
/* rand is between 0 and UINT32_MAX - 1 / 2 (because sign) */
return rand() + rand() + (rand() % 1);
}
static uint64_t
ipow(uint32_t base, uint32_t exp)
{
int result = 1;
for (;;)
{
if (exp & 1)
result *= base;
exp >>= 1;
if (!exp)
break;
base *= base;
}
return result;
}
static uint64_t
ipow_mod(uint32_t base, uint32_t exponent, uint32_t mod) {
uint64_t x = 1;
uint64_t y = base;
while (exponent > 0) {
if (exponent % 2 == 1)
x = (x * y) % mod;
y = (y * y) % mod;
exponent = exponent / 2;
}
return (x % mod);
}
static uint32_t
E1(char message, uint32_t key_priv, uint32_t n){
return ipow_mod(message, key_priv, n);
}
static uint32_t
D1(char cypher, uint32_t key_pub, uint32_t n){
return ipow_mod(cypher, key_pub, n);
}
inline static uint32_t
Sign2(char message, uint32_t key_priv, uint32_t n){
return E1(message, key_priv, n);
}
inline static uint32_t
Verif2(char signature, uint32_t key_pub, uint32_t n){
return D1(signature, key_pub, n);
}