From 0b3e805a1780847a365914bf75d693382d8bfd79 Mon Sep 17 00:00:00 2001 From: alexdbrz <167307390+alexdbrz@users.noreply.github.com> Date: Mon, 22 Apr 2024 12:44:18 +0200 Subject: [PATCH] Add files via upload --- ntruencrypt/Makefile | 11 + ntruencrypt/all | Bin 0 -> 26832 bytes ntruencrypt/main.c | 21 ++ ntruencrypt/main.o | Bin 0 -> 2160 bytes ntruencrypt/polynome.c | 459 +++++++++++++++++++++++++++++++++ ntruencrypt/polynome.h | 101 ++++++++ ntruencrypt/polynome.o | Bin 0 -> 13520 bytes ntruencrypt/queue_pol.c | 109 ++++++++ ntruencrypt/queue_pol.h | 12 + ntruencrypt/queue_pol.o | Bin 0 -> 3384 bytes ntruencrypt/test.c | 185 +++++++++++++ ntruencrypt/test.h | 25 ++ ntruencrypt/test.o | Bin 0 -> 9160 bytes ntruencrypt/test2.c | 100 +++++++ ntruencrypt/test2.h | 6 + ntruencrypt/test_div_euc_p.txt | 5 + 16 files changed, 1034 insertions(+) create mode 100644 ntruencrypt/Makefile create mode 100644 ntruencrypt/all create mode 100644 ntruencrypt/main.c create mode 100644 ntruencrypt/main.o create mode 100644 ntruencrypt/polynome.c create mode 100644 ntruencrypt/polynome.h create mode 100644 ntruencrypt/polynome.o create mode 100644 ntruencrypt/queue_pol.c create mode 100644 ntruencrypt/queue_pol.h create mode 100644 ntruencrypt/queue_pol.o create mode 100644 ntruencrypt/test.c create mode 100644 ntruencrypt/test.h create mode 100644 ntruencrypt/test.o create mode 100644 ntruencrypt/test2.c create mode 100644 ntruencrypt/test2.h create mode 100644 ntruencrypt/test_div_euc_p.txt diff --git a/ntruencrypt/Makefile b/ntruencrypt/Makefile new file mode 100644 index 0000000..8e1ec7f --- /dev/null +++ b/ntruencrypt/Makefile @@ -0,0 +1,11 @@ +CC=gcc +objets= polynome.o queue_pol.o main.o test.o + +all : $(objets) + $(CC) -o $@ $^ + +%.o : %.c + gcc -c -Wall $< + +clean : + rm -f all *.o diff --git a/ntruencrypt/all b/ntruencrypt/all new file mode 100644 index 0000000000000000000000000000000000000000..2a5f9dd7689fc2617ddd4f1e7d3eb6c4d6b9ee46 GIT binary patch literal 26832 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 BmKXp4 literal 0 HcmV?d00001 diff --git a/ntruencrypt/main.c b/ntruencrypt/main.c new file mode 100644 index 0000000..c758cd0 --- /dev/null +++ b/ntruencrypt/main.c @@ -0,0 +1,21 @@ +#include +#include +#include +#include "polynome.h" +#include "test.h" + +int main() +{ + polynomial_d *t1=empty_pol(); + t1->p[0]=1; + t1->p[1]=-1; + degr(t1); + print_pol(t1);printf("\n"); + polynomial_d *test=empty_pol(); + print_pol(test); + lin_comb(empty_pol(),t1->p[t1->deg],t1,test); + print_pol(test);printf("\n"); + test_div_euc_p(); + + return 0; +} diff --git a/ntruencrypt/main.o b/ntruencrypt/main.o new file mode 100644 index 0000000000000000000000000000000000000000..e1c45a279921793d9e4918035c9a6c290ed5da6b GIT binary patch literal 2160 zcmbu9&1(}u6u{pmwXNFP_yHCw5>Q0JE=lRdBC>5vyGXQP8$4)PHtE^~^RaFw(t6NC zKnS^b@X({j9{dBmS*sAd>B*b)BJ|)zyopfXo1JMU+ue&kc>CV`=DjzwGyC>=Ha8#B zG?1df4d{&|1xOv~`383l7=;n|HFo}Y-fVwgGFv~!-_pb$Jmv$Z|Y zg?$tb+Fd`IB8C6%n5@xPZ4cx3WQ<=dL8fC2o15nQ-I%F;?(}V-Yj*OKg_XaU?Va{F zxzs_K-co#uuV=PCj^AJT01KJSO!9KR(5$g$@|r%arzX=)K1x5EO6jR-J$=RJ^tu28 zs0ma$riD9shyiR9i=&d9@eOEC?}E0T&?ZKPhF{`AUqpUR%zY)BJ&|}3%Zv_YTk+T@ z3=(ruhVE(re(s0O$3t(D_9S=JpB3kC(a&fUhrz>;^PvbHzUw$Yo&FSxJf-ZDp8>K_ zR65U~TtE=UCnNY&1iv1^Z$|Lj5ge*^xuzGn0c#<*I5(TK7U$=evdh-;>|8Eufm3za zhUL~Pu(v4VCQkr+b!ll7eGjQE&A`Z){YVT>!noJl~e2=Q$NyXU;kUebr_*=!HfDbUf**Q$tp( zGe^f>ooq0>_(+V`YE9ks>aOFl4bXW7r(`|!?5fjS^FO>K=2FiFJIX*tBENrs% z>;x*ErGcu-YthofR2+r=qU6d>94Cl!36*&84{%oGQH&} +#include +#include +#include "polynome.h" +/* Renvoie le polynome nul possedant N coefficients */ +polynomial_d *empty_pol () +{ + polynomial_d *p_d; + p_d=malloc(sizeof(polynomial_d)); + p_d->deg=0; + p_d->p=calloc(N, sizeof (int)); + return p_d; +} + +/* Remet un polynome à zéro */ +void zero(polynomial_d *u){ + for(int k=0;kp[k]=0; + } +} + +/* Renvoie le polynome X^n */ +polynomial_d *X(int n){ + polynomial_d *p_dxn = empty_pol(); + p_dxn->p[n]=1; + p_dxn->deg=n; + return p_dxn; +} + +/* Met le degré du polynome_d u au degré de u */ +void degr(polynomial_d *u){ + u->deg=N; + while((u->p[u->deg]==0)&&(u->deg>=1)){ + u->deg--; + } +} + +/* Affiche le polynome donné en entrée */ +void print_pol(polynomial_d *u){ + if(u->deg ==0){ + printf("%d\n",u->p[0]); + } + else { + int first_non_zero=0; + while (u->p[first_non_zero]==0){ + first_non_zero++; + } + if(first_non_zero==0){ + printf("%d ",u->p[first_non_zero]); + } + else if(first_non_zero==u->deg){ + if(u->p[first_non_zero]==1){ + printf("X^%d",first_non_zero); + } + else{ + printf("%dX^%d",u->p[first_non_zero],first_non_zero); + } + } + else{ + if(u->p[first_non_zero]==1){ + printf("X^%d ",first_non_zero); + } + else{ + printf("%dX^%d ",u->p[first_non_zero],first_non_zero); + } + } + for (int k=first_non_zero + 1; kdeg; k++){ + if(u->p[k]<0){ + if(u->p[k]==-1){ + printf("- X^%d ",k); + } + else{ + printf("- %dX^%d ",-u->p[k],k); + } + } + else if(u->p[k]>0){ + if(u->p[k]==1){ + printf("+ X^%d ",k); + } + else{ + printf("+ %dX^%d ",u->p[k],k); + } + } + } + if(first_non_zero!=u->deg){ + if(u->p[u->deg]<0){ + if(u->p[u->deg]==-1){ + printf("- X^%d\n",u->deg); + } + else{ + printf("- %dX^%d\n",-u->p[u->deg],u->deg); + } + } + else if(u->p[u->deg]>0){ + if(u->p[u->deg]==1){ + printf("+ X^%d\n",u->deg); + } + else{ + printf("+ %dX^%d\n",u->p[u->deg],u->deg); + } + } + } + else{ + printf("\n"); + } + } +} + +/* Affiche le polynome donné en entrée dans le fichier out*/ +void print_pol2(FILE *out, polynomial_d *u){ + if(u->deg ==0){ + fprintf(out,"%d\n",u->p[0]); + } + else { + int first_non_zero=0; + while (u->p[first_non_zero]==0){ + first_non_zero++; + } + if(first_non_zero==0){ + fprintf(out,"%d ",u->p[first_non_zero]); + } + else if(first_non_zero==u->deg){ + if(u->p[first_non_zero]==1){ + fprintf(out,"X^%d",first_non_zero); + } + else{ + fprintf(out,"%dX^%d",u->p[first_non_zero],first_non_zero); + } + } + else{ + if(u->p[first_non_zero]==1){ + fprintf(out,"X^%d ",first_non_zero); + } + else{ + fprintf(out,"%dX^%d ",u->p[first_non_zero],first_non_zero); + } + } + for (int k=first_non_zero + 1; kdeg; k++){ + if(u->p[k]<0){ + if(u->p[k]==-1){ + fprintf(out,"- X^%d ",k); + } + else{ + fprintf(out,"- %dX^%d ",-u->p[k],k); + } + } + else if(u->p[k]>0){ + if(u->p[k]==1){ + fprintf(out,"+ X^%d ",k); + } + else{ + fprintf(out,"+ %dX^%d ",u->p[k],k); + } + } + } + if(first_non_zero!=u->deg){ + if(u->p[u->deg]<0){ + if(u->p[u->deg]==-1){ + fprintf(out,"- X^%d\n",u->deg); + } + else{ + fprintf(out,"- %dX^%d\n",-u->p[u->deg],u->deg); + } + } + else if(u->p[u->deg]>0){ + if(u->p[u->deg]==1){ + fprintf(out,"+ X^%d\n",u->deg); + } + else{ + fprintf(out,"+ %dX^%d\n",u->p[u->deg],u->deg); + } + } + } + else{ + fprintf(out,"\n"); + } + } +} + +/* print le tableau représentant le polynome u */ +void print_pol_o(polynomial_d *u){ + printf("[%d;",u->p[0]); + for(int k=1;kp[k]); + } + printf("%d]\n",u->p[N-1]); + degr(u); +} + +/* Renvoie value à la puissance power */ +int pow_opt(int value, int power){ + int r=value; + for(int k=1;kdeg; k++) + { + p_dmp->p[k]=u->p[k]%P; + } + degr(u); +} +void modulo_q (polynomial_d *u, polynomial_d *p_dmq) +{ + for (int k = 0; k<=u->deg; k++) + { + p_dmq->p[k]=u->p[k]%Q; + } + degr(u); +} +/* Renvoie un pointeur sur la combinaison linéaire de deux polynômes u et v et d'un entier relatif break +* Renvoie u+ kv */ +void lin_comb(polynomial_d *u, int l, polynomial_d *v, polynomial_d *p_dcl){ + for (int k=0; k<=u->deg || k<=v->deg; k++){ + p_dcl->p[k]= u->p[k] + l*v->p[k]; + } + degr(p_dcl); +} + +/* Renvoie le produit de convolution de deux polynomes */ +void conv(polynomial_d *u, polynomial_d *v, polynomial_d *p_dc) +{ + for (int k=0; kp[k]= p_dc->p[k] + u->p[i]*v->p[k-i]; + } + for (int i=N+k-v->deg; i<=u->deg; i++){ + p_dc->p[k]= p_dc->p[k] + u->p[i]*v->p[N+k-i]; + + } + } + degr(p_dc); +} + +/* Renvoie le center lift d'un polynome f + * dont on a donné en argument le polynbome */ +void center_lift(polynomial_d *u, polynomial_d *p_dl){ + int coef; + for(int k=0; k<=u->deg; k++){ + coef = u->p[k]%Q; + if(2*coef>Q){ + p_dl->p[k] = Q-coef; + } + else{ + p_dl->p[k] = coef; + } + } +} + +/* fonction auxiliaire de div_euc permettant de remettre le degré de r à son actuel degré, + * car celui ci décroit à chque itération de la boucle while */ +void deg_dec(polynomial_d *u){ + while((u->p[u->deg]==0)&&(u->deg>=1)){ + u->deg--; + } +} + +/* Fait la division euclidienne de u par v dans R_p + * v doit être unitaire + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void div_euc_p(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){ + r->p=u->p; + + if(u->degdeg){ + r->deg=u->deg; + } + else{ + degr(r); + + q->deg=u->deg-v->deg; + polynomial_d *p_dc=empty_pol(); + + int v_inv_p = pow_opt(v->p[v->deg],P-1)%P; + int i=0; + + while (r->deg >= v->deg){ + printf("on est la (%d)\n",i); + printf("r :"); + print_pol(r); + + printf("q :"); + print_pol(q); + + conv(X(r->deg-v->deg), v, p_dc); + printf("p_dc :"); + print_pol(p_dc); + printf("\n"); + + q->p[r->deg-v->deg]=r->p[r->deg]*v_inv_p%P; + + lin_comb(r, -1*r->p[r->deg]*v_inv_p, p_dc, r); + zero(p_dc); + + i++; + + } + free(p_dc); + } +} +/* Fait la division euclidienne de u par v dans R_q + * v doit être unitaire + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void div_euc_q(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){ + r->p=u->p; + + if(u->degdeg){ + r->deg=u->deg; + } + else{ + degr(r); + + q->deg=u->deg-v->deg; + polynomial_d *p_dc=empty_pol(); + + int v_inv_q =pow_opt(v->p[v->deg],Q-1)%Q; + int i=0; + + while (r->deg >= v->deg){ + printf("on est la (%d)\n",i); + printf("r :"); + print_pol(r); + + printf("q :"); + print_pol(q); + + conv(X(r->deg-v->deg), v, p_dc); + printf("p_dc :"); + print_pol(p_dc); + printf("\n"); + + q->p[r->deg-v->deg]=r->p[r->deg]*v_inv_q%Q; + + lin_comb(r, -1*r->p[r->deg]*v_inv_q, p_dc, r); + zero(p_dc); + + i++; + + } + free(p_dc); + } +} + +/* Fait la division euclidenne de dom(v)u par v + * v peut donc ne pas être unitaire + * Modifie les arguments r reste et q quotient donnée en argument */ +void div_euc(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q){ + if(v->p[v->deg]==1){ + div_euc_q(u,v,r,q); + } + else{ + polynomial_d *p_dc=empty_pol(); + r->deg=u->deg; + r->p=u->p; + int i=0; + while (r->deg >= v->deg){ + lin_comb(empty_pol(),v->p[v->deg],r,r); + printf("on est la(%d)\n",i); + printf("r :"); + print_pol(r); + lin_comb(empty_pol(),v->p[v->deg],q,q); + printf("q :"); + print_pol(q); + printf("v :"); + print_pol(v); + conv(X(r->deg-v->deg), v, p_dc); + printf("p_dc :"); + print_pol(p_dc); + printf("\n"); + q->p[r->deg-v->deg]=r->p[r->deg]/v->p[v->deg]; + degr(q); + lin_comb(r, -1*(r->p[r->deg]/v->p[v->deg]), p_dc, r); + zero(p_dc); + i++; + } + free(p_dc); + } +} + +/* Rend unitaire un polynome u */ +void unitaire(polynomial_d *u){ + for (int k=0;k<=u->deg;k++){ + u->p[k]=u->p[k]/u->p[u->deg]; + } +} + +/* Fait le pgcd de u et v + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void pgcd_o(polynomial_d *u, polynomial_d *v, polynomial_d *rn){ + rn->deg=u->deg; + rn->p=u->p; + polynomial_d *rn_plus_1; + rn_plus_1 = empty_pol(); + rn_plus_1->deg=v->deg; + rn_plus_1->p=v->p; + polynomial_d *q=empty_pol(); + polynomial_d *aux=empty_pol(); + while((rn_plus_1->deg!=0)||(rn_plus_1->p[0]!=0)){ + div_euc(rn,rn_plus_1,rn,q); + aux->deg=rn->deg; + aux->p=rn->p; + rn->deg=rn_plus_1->deg; + rn->p=rn_plus_1->p; + rn_plus_1->deg=aux->deg; + rn_plus_1->p=aux->p; + } + free(rn_plus_1); + unitaire(rn); +} +/* Fait le pgcd de u et v + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void pgcd(polynomial_d *u, polynomial_d *v, polynomial_d *rn, queue_pol **q_p){ + rn->deg=u->deg; + rn->p=u->p; + + polynomial_d *rn_plus_1=empty_pol(); + rn_plus_1->deg=v->deg; + rn_plus_1->p=v->p; + + polynomial_d *qn=empty_pol(); + polynomial_d *aux=empty_pol(); + while((rn_plus_1->deg!=0)||(rn_plus_1->p[0]!=0)){ + queue_post(q_p,qn); + div_euc(rn,rn_plus_1,rn,qn); + aux->deg=rn->deg; + aux->p=rn->p; + rn->deg=rn_plus_1->deg; + rn->p=rn_plus_1->p; + rn_plus_1->deg=aux->deg; + rn_plus_1->p=aux->p; + } + free(rn_plus_1); + unitaire(rn); +} +/* Trouve deux suites de polynomes an et bn pour tout n on ait + * rn-1=u*an-1 + v*bn-1 + * rn=u*an + v*bn + * rn-1= qn*rn +rn-1 -> rn+1= qn*(u*an +v*bn) +u*an-1 +v*bn-1 + * rn+1=u*(qn*an+an-1) + v*(qn*bn+bn-1) + * an+1=qn*an +an-1 ; a0=1 et a1=0 + * bn+1=qn*bn +bn-1 ; b0=0 et b1=1 + * Il s'agit donc d'avoir la suite de polynome (qn) + */ +void bezout(polynomial_d *u, polynomial_d *v, polynomial_d *rn, polynomial_d *an, polynomial_d *bn, queue_pol *q_p){ + pgcd(u,v,rn,&q_p);} + + +/* Renvoie l'inverse d'un polynome f dans l'anneau F_p ou F_q +polynomial *inv_p (polynomial f){ + p111 An intro to matghematical gngn + p402 +} +polynomial *inv_q (polynomial f); +*/ diff --git a/ntruencrypt/polynome.h b/ntruencrypt/polynome.h new file mode 100644 index 0000000..3f694ce --- /dev/null +++ b/ntruencrypt/polynome.h @@ -0,0 +1,101 @@ +#ifndef POLYNOME_H +#define POLYNOME_H + + +/* on choisit le triplet public (N,p,q) au debut du programme +* TOUS les polynomes seront de degré N-1 */ +#define N 11 +#define P 7 +#define Q 2 +/* les polynomes seront donc representés par des tableaux de taille N */ +typedef int * polynomial; + +struct polynomial_s{ + polynomial p; + int deg; +}; +typedef struct polynomial_s polynomial_d; + +struct queue_pol_s +{ + struct queue_pol_s *prev; + struct queue_pol_s *next; + polynomial_d *p_d; +}; + +typedef struct queue_pol_s queue_pol; +#include "queue_pol.h" +/* print le polynome sous sa forme mathematique */ +void print_pol(polynomial_d *u); +/* print le tableau représentant le polynome u */ +void print_pol_o(polynomial_d *u); + +/* print le polynome sous sa forme mathematique dans le fichier texte out*/ +void print_pol2(FILE *out, polynomial_d *u); + +/* Renvoie le polynôme nul possèdant N coefficient */ +polynomial_d *empty_pol(); + +/* Remet à zero un polynome */ +void zero(polynomial_d *u); + +/* Renvoie le polynome X^n */ +polynomial_d *X(int n); + +/* Met le degré du polynome_d u au degré de u */ +void degr(polynomial_d *u); + +/* Renvoie value à la puissance power */ +int pow_opt(int value, int power); + +/* Renvoie un pointeur sur le polynôme f où ses coefficients sont modulos n, où n=p ou n=q */ +void modulo_p(polynomial_d *u, polynomial_d *p_dmp); +void modulo_q(polynomial_d *u, polynomial_d *p_dmq); + +/* Renvoie un pointeur sur le polynôme f modulo X^N-1 +* où N est le paramètre que l'on se donne au début du chiffrement */ +void modulo_N(polynomial_d *u, polynomial_d *p_dmN); + +/* Renvoie un pointeur sur la combinaison linéaire de deux polynômes u et v et d'un entier relatif break +* Renvoie u+ kv */ +void lin_comb(polynomial_d *u, int k, polynomial_d *v, polynomial_d *p_dcl); + +/* Renvoie un pointeur sur le produit de convolution de deux polynômes */ +void conv(polynomial_d *u, polynomial_d *v, polynomial_d *p_dc); + +/* Renvoie le center lift du polynome f */ +void center_lift(polynomial_d *u, polynomial_d *p_dl); + +/* Renvoie un pointeur sur l'inverse d'un polynôme f dans l'anneau F_n, où n=p ou n=q */ +void inv(polynomial_d *u, int n); + +/* fonction auxiliaire de div_euc permettant de remettre le degré de r à son actuel degré, + * car celui ci décroit à chque itération de la boucle while */ +void deg_dec(polynomial_d *u); +/* Fait la division euclidienne de u par v dans R_p + * v doit être unitaire + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void div_euc_p(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q); +/* Fait la division euclidienne de u par v dans R_q + * v doit être unitaire + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void div_euc_q(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q); +/*Modifie les arguments r, reste et q, quotient donnée en argument */ +void div_euc(polynomial_d *u, polynomial_d *v, polynomial_d *r, polynomial_d *q); + +/* Rend unitaire un polynome u */ +void unitaire(polynomial_d *u); +/* Fait le pgcd de u et v + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void pgcd_o(polynomial_d *u, polynomial_d *v, polynomial_d *rn); + /* Fait le pgcd de u et v + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void pgcd(polynomial_d *u, polynomial_d *v, polynomial_d *rn, queue_pol **q_p); +/* Fait le pgcd de u et v + * Modifie les arguments r, reste et q, quotient donnée en argument */ +void bezou(polynomial_d *u, polynomial_d *v, polynomial_d *rn, polynomial_d *an, polynomial_d *bn, queue_pol* q_p); + +polynomial_d *inv_q(polynomial); +polynomial_d *inv_p(polynomial); + +#endif diff --git a/ntruencrypt/polynome.o b/ntruencrypt/polynome.o new file mode 100644 index 0000000000000000000000000000000000000000..a3f8ea94239e16a65e50e76e98bd93a545d3a34e GIT binary patch literal 13520 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 CM6cHX literal 0 HcmV?d00001 diff --git a/ntruencrypt/queue_pol.c b/ntruencrypt/queue_pol.c new file mode 100644 index 0000000..e12920a --- /dev/null +++ b/ntruencrypt/queue_pol.c @@ -0,0 +1,109 @@ +#include +#include +#include "queue_pol.h" +#include "polynome.h" +static void queue_first (queue_pol**); +static void queue_prev (queue_pol**); +static void queue_last (queue_pol**); +static void queue_next (queue_pol**); + +queue_pol*queue_new (void) +{ + return (NULL); +} + +void queue_post (queue_pol** pp_queue, polynomial_d *p_d) +{ + if (pp_queue != NULL) + { + queue_pol*p_l = NULL; + queue_pol*p_p = NULL; + + queue_first (pp_queue); + p_l = *pp_queue; + p_p = malloc (sizeof (*p_p)); + if (p_p != NULL) + { + p_p->p_d = p_d; + p_p->next = p_l; + p_p->prev = NULL; + if (p_l != NULL) + p_l->prev = p_p; + *pp_queue = p_p; + } + else + { + fprintf (stderr, "Memoire insuffisante\n"); + exit (EXIT_FAILURE); + } + } + return; +} + +void queue_get (queue_pol** pp_queue, polynomial_d *p_d) +{ + if (pp_queue != NULL && *pp_queue != NULL) + { + queue_pol*p_l = NULL; + queue_pol*p_p = NULL; + + queue_last (pp_queue); + p_l = *pp_queue; + if (p_l != NULL) + p_p = p_l->prev; + p_d->deg = p_l->p_d->deg; + p_d->p = p_l->p_d->p; + free (p_l); + p_l = NULL; + if (p_p != NULL) + p_p->next = NULL; + *pp_queue = p_p; + } +} + +void queue_delete (queue_pol** pp_queue) +{ + polynomial_d *p_dd=empty_pol(); + if (pp_queue != NULL && *pp_queue != NULL) + { + while (*pp_queue != NULL){ + queue_get (pp_queue,p_dd); + free(p_dd); + } + } + return; +} + +static void queue_first (queue_pol** pp_queue) +{ + if (pp_queue != NULL && *pp_queue != NULL) + { + while ((*pp_queue)->prev != NULL) + queue_prev (pp_queue); + } + return; +} + +static void queue_prev (queue_pol** pp_queue) +{ + if (pp_queue != NULL && *pp_queue != NULL) + *pp_queue = (*pp_queue)->prev; + return; +} + +static void queue_last (queue_pol** pp_queue) +{ + if (pp_queue != NULL && *pp_queue != NULL) + { + while ((*pp_queue)->next != NULL) + queue_next (pp_queue); + } + return; +} + +static void queue_next (queue_pol** pp_queue) +{ + if (pp_queue != NULL && *pp_queue != NULL) + *pp_queue = (*pp_queue)->next; + return; +} diff --git a/ntruencrypt/queue_pol.h b/ntruencrypt/queue_pol.h new file mode 100644 index 0000000..7456ad7 --- /dev/null +++ b/ntruencrypt/queue_pol.h @@ -0,0 +1,12 @@ +#ifndef QUEUE_POL_H +#define QUEUE_POL_H + +#include "polynome.h" + + +queue_pol *queue_new (void); +void queue_post (queue_pol **, polynomial_d *); +void queue_get (queue_pol **, polynomial_d *); +void queue_delete (queue_pol **); + +#endif diff --git a/ntruencrypt/queue_pol.o b/ntruencrypt/queue_pol.o new file mode 100644 index 0000000000000000000000000000000000000000..bca5f1561958a149bf7101466fea592498dd9da5 GIT binary patch literal 3384 zcmbtVO=w(29G}g`HrjlwsY<1i?m@(_J`;(D29?*Oo4iA`r8c0btefO*yLP{P`_?A4 zwS_jqvZ#AjK`%mXilZs;NEQBV|m$ic!wL{_{63Dn~v2gA~Z$B^P;`es1R#+w|QH#wipxx;;*5RzvrCFtu_zEE%@>Stf63y!eAZ$p5N@5%K+rpoOeA}tc zZ90_`F~v8*_ep+($^x2A;qL>|gyyzWp(310cI$DcdRO3c{p`NdQ`xT6hpv9ey{<@Cs46?rQJJcR8KM?hYrxvEs;p#F7gV*8JJUzKTu{tL za3VU8thFDarn6!9AqADw98M+Hr2u(Dfs5c!8^WJ}xjgihx^HbAk|!k-|G5<|9J-}k z{;Ad(A%@FV#o?HP;^1>+iwVly_Xi2evQha;y?m>~N6UUBWIwEVc@(_RTCJnWLUEta zx`=zI9rwO)T)U5ff9oC?<+l>wule9wbmSM@Tp{DR@l3u{PNy@aRNi;*5n^U)Y9jvV z+WzP}^{lH1fd)B1_<*yM3t#fM0*IM!m z#6k0%TJl#~@=u6^j&aiRciQp4Ar2bnq~&MZ@|(m#2|20!FSO-5QYyqVVR<%?E72Vb zKiOXK=j}TL0HR%AGUEEQJFTMfb~-WcqVl#n@d0dm;D3h+faIBAeGr4VkBcSATCqNi zLEKijJR@LFDg2tkW$nO7QL#5*j5#Xg=Wd|X4?WT$X;kb9?E-cJ%W&v?WKRKO9mMrs z_7bq;80=e@Ij|7ySG#_$A=X=U1#G*}GUP7~SH20G#?Cse6&V4D91w^u=3c zx9ld1g{-xp_;kiA`HIh`T5QpC-&SbeUD679_gu>bRFgBa$0v`@CXY`~zmzzYJau$( zHjxy$R5n{!5G8-n^*oV2=Vg3XxJw!B|40x-oNtiEbLt$4KM=yd4B`A+YyF!c zoIhEOH$r&WPaHZV=EbUl9=HuU74Nv6G2j$hpWr#M{jO3atR21fcLd>PoQ>yt802Qk +#include +#include +#include "test.h" +#include "queue_pol.h" + +/* Initialise le polynome u à la valeur souhaité par l'utilisateur */ +void def_pol(polynomial_d *u){ + int coef,val_coef; + int is_well_def=0; + while (is_well_def==0){ + int go_on_def_pol=1; + while(go_on_def_pol==1){ + printf("X^"); + scanf("%d",&coef); + scanf("%d",&val_coef); + printf("go_on_def_pol OUI(1) NON(0) :"); + scanf("%d",&go_on_def_pol); + printf("\n"); + u->p[coef]=val_coef; + } + degr(u); + print_pol(u); + /* print_pol_o(u);*/ + printf("Est-ce le bon polynome ? OUI(1) NON(0) "); + scanf("%d",&is_well_def); + printf("\n"); + } +} + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_div_euc_p_o(void){ + int go_on=1; + + polynomial_d *u=empty_pol(); + polynomial_d *v=empty_pol(); + polynomial_d *r=empty_pol(); + polynomial_d *q=empty_pol(); + while(go_on==1){ + printf("/* begin div_eucl test */\n"); + printf("Initialisation de u :\n"); + def_pol(u); + print_pol(u); + printf("deg u :%d\n",u->deg); + printf("Initialisation de v :\n"); + def_pol(v); + print_pol(v); + printf("deg v :%d",v->deg); + div_euc(u,v,r,q); + printf("r : "); + print_pol(r); + printf("q : "); + print_pol(q); + printf("/* end div_eucl test */\n\n"); + printf("go_on OUI(1) NON(0) :"); + scanf("%d",&go_on); + printf("\n"); + } + free(u); + free(v); + free(r); + free(q); +} + +/* Initialise le polynome u à la valeur souhaité par l'utilisateur */ +void get_pol(FILE *in, polynomial_d *u){ + int coef,val_coef; + + while(getc(in)!='\n'){ + fscanf(in,"%d %d",&coef,&val_coef); + u->p[coef]=val_coef; + } + degr(u); +} + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_div_euc_p(void){ + FILE *in = fopen("test_div_euc_p.txt","r"); + + if (in == NULL) + { + printf("Cannot open the source file.\n"); + exit(1); + } + + char ch; + + polynomial_d *u = empty_pol(); + polynomial_d *v = empty_pol(); + polynomial_d *r = empty_pol(); + polynomial_d *q = empty_pol(); + + while(!feof(in)){ + printf("/* begin div_eucl test */\n"); + + printf("u :"); + get_pol(in,u); + print_pol(u); + printf("deg u :%d\n",u->deg); + + printf("v :"); + get_pol(in,v); + print_pol(v); + printf("deg v :%d\n\n",v->deg); + + div_euc_p(u,v,r,q); + printf("r : "); + print_pol(r); + + printf("q : "); + print_pol(q); + + printf("/* end div_eucl test */\n\n"); + + ch = getc(in); + } + free(u); + free(v); + free(r); + free(q); +} + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol() */ +void test_pgcd_o(void){ + int go_on=1; + polynomial_d *u=empty_pol(); + polynomial_d *v=empty_pol(); + polynomial_d *rn=empty_pol(); + while(go_on==1){ + printf("/* begin pgcd test */\n"); + printf("Initialisation de u :\n"); + def_pol(u); + print_pol(u); + printf("deg u :%d\n\n",u->deg); + printf("Initialisation de v :\n"); + def_pol(v); + print_pol(v); + printf("deg v :%d\n\n",v->deg); + pgcd_o(u,v,rn); + printf("rn : "); + print_pol(rn); + printf("/* end pgcd test */\n\n"); + printf("go_on OUI(1) NON(0) :"); + scanf("%d",&go_on); + printf("\n"); + } + free(u); + free(v); + free(rn); +} + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_pgcd(void){ + int go_on=1; + queue_pol *q_p; + q_p=queue_new(); + polynomial_d *u=empty_pol(); + polynomial_d *v=empty_pol(); + polynomial_d *rn=empty_pol(); + while(go_on==1){ + printf("/* begin pgcd test */\n"); + printf("Initialisation de u :\n"); + def_pol(u); + print_pol(u); + printf("deg u :%d\n\n",u->deg); + printf("Initialisation de v :\n"); + def_pol(v); + print_pol(v); + printf("deg v :%d\n\n",v->deg); + pgcd(u,v,rn,&q_p); + printf("rn : "); + print_pol(rn); + printf("/* end pgcd test */\n\n"); + printf("go_on OUI(1) NON(0) :"); + scanf("%d",&go_on); + printf("\n"); + } + free(u); + free(v); + free(rn); +} diff --git a/ntruencrypt/test.h b/ntruencrypt/test.h new file mode 100644 index 0000000..3adee4f --- /dev/null +++ b/ntruencrypt/test.h @@ -0,0 +1,25 @@ +#ifndef TEST_H +#define TEST_H +#include "polynome.h" +/* Initialise le polynome u à la valeur souhaité par l'utilisateur */ +void def_pol(polynomial_d *u); + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_div_euc_p_o(void); + +/* Initialise le polynome u à la valeur souhaité par l'utilisateur */ +void get_pol(FILE *in, polynomial_d *u); + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test div_euc(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_div_euc_p(void); + +/* Crée autant de polynomes u et v que l'utilisateur souhaite + * puis test pgcd(u,v,r,q) r et q ayant déjà été initialisés à empty_pol()*/ +void test_pgcd(void); + +#endif + + + diff --git a/ntruencrypt/test.o b/ntruencrypt/test.o new file mode 100644 index 0000000000000000000000000000000000000000..2472167f6838f54f7e083d6315ab1ff6c899f97d GIT binary patch literal 9160 zcmd5=eQX>@6(8GilA3(-k*00ZF3?12m0WBHAC400#%yvHc8uCsR3hr-e79#`W8Yox z_KMxF1SKIH$Ehg^f3zjENT4cEL92+0KZ+7kgi`{jM4>gR1*QdLt7$R9NY^H+d2e^- z{M)&kxN81kq`jH_&F{T=^WK}cd%Mr>++JT-CseBwUl6l*3Kb%3&5ql=VVhVY7K{HZ zz46_iaN!@}0~edag@;Dt;o`hC>xd98*yWbfBlZ-NC;4~8o@ULHCHe`Mw$iWo1^-O& zPq<`HgbTl^gy12&pZ{!=LtD<2HKgUwRRpSLL`1>@09l z!5$6VjR)=~0(VoB*O9bzru47puj+l_9%)=`TUav+0qJq@P+)A3E_O|Y+3m&rc)-6^ zJ}q(*Naxp>B!>qkac8jql6_&W$XxIO{@Qz00mtpk+CrgJOV1rji_QUw=Et>=zS$Zs zbxns$J>(49XX!Iu-WNu|@}f-+q70qF44p32djfLr2g*(P=Lx7-I=4m5YBArZzS}6D z!UrB275NpIC#N{;JOY?iu&RP3 zW8J2a#l~B$UZ*davf|16B2GRwV7X4twQk)gI#NkD868OGqHdB@#2qV7y5mkC_iN%! zH3;`f0`+8M*4k`|d-;bJaZ>TBC7S$wXeMo@4O%QN*pi5}E0PJhL#}9#rc!CwN@tvu z<@P&PE}hTPHWSGKCnVUufC)`av-`{R#p0E{&F-Q}WK&=wvgk!?M|=BbYh6!oKIP`E z*3hO<^M;nZch~aprn@Zb_Hvc5#|-=v2K=W|&*M^$ zm(zs((!hVwfS)wrXASu831|EF@&TvjofYcO(^V_Jer?o#L9Cn`jqQ!Z`u9c>(d2+uZzE~p3})P6k4q|YLY88Y$U2Vbb6lxKu9ff? zBRr;Q5(%!?!Wl}sBH^SH{xp|bTEi>yJQnxnoxBrCIbS0e2>&T2xPE%4`!fCOc zB=AvxM&qxN_S|pamjFk59s?ZhIicydr2dn@M|;izz8dy>UelxM&lvDg&jjFT&%ZQ1 z&&YVa1ANreDBtsV8ucuaxQe@~Kg)rSabFEMp0D+Q-w69{103r{rvbmqfX5B^QNS^u ze_+6WX24HLT=`+WjPI|3kA66(@zwM9WdnZr_hyZ+&P53LX#W8#kLFg zu0x-NL-D8^6`|f-PK2^)|0b3m9CT7NM<0xx5Pgf?;C=3p_kF2+D3hh{5?ObcWLT5a zA4z1RgO0T1>N<`SrrUoHO|nj1{wXQ1zUwF*x;$rL zt@yXy-iA0Ib4%K!iX literal 0 HcmV?d00001 diff --git a/ntruencrypt/test2.c b/ntruencrypt/test2.c new file mode 100644 index 0000000..ed94d00 --- /dev/null +++ b/ntruencrypt/test2.c @@ -0,0 +1,100 @@ +#include +#include +#include "test2.h" + +/* Initialise le polynome u à la valeur souhaité par l'utilisateur */ +void get_pol(FILE *in, polynomial_d *u){ + int coef,val_coef; + + while(getc(in)!='\n'){ + fscanf("%d %d",&coef,&val_coef); + u->p[coef]=val_coef; + } + degr(u); + + printf("\n"); +} + +void test_div_euc_p() +{ + FILE *in, *out; + + in = fopen("test_div_euc_o _p.txt", "r"); + if (in == NULL) + { + printf("Cannot open the source file.\n"); + exit(1); + } + + out = fopen("result_div_euc_o_p.txt", "w"); + if (out == NULL) + { + printf("Cannot open the destination file.\n"); + exit(1); + } + + char ch; + + // faire jusqu'à ce que la fin du fichier soit atteinte + while (!feof(in)) + { + // lit la prochaine paire d'entrées du fichier + get_pol(in,u); + get_pol(in,v); + + // calcule pgcd et imprime dans le fichier de sortie + print_pol2(out,r); + print_pol2(out,q); + + // passe à la ligne suivante + ch = getc(in); + } + + // ferme le flux de fichiers d'entrée et de sortie + fclose(out); + fclose(in); +} + +void test_div_euc_q() +{ + FILE *in, *out; + + in = fopen("test_div_euc_o_q.txt", "r"); + if (in == NULL) + { + printf("Cannot open the source file.\n"); + exit(1); + } + + out = fopen("result_div_euc_o_q.txt", "w"); + if (out == NULL) + { + printf("Cannot open the destination file.\n"); + exit(1); + } + + char ch; + + // faire jusqu'à ce que la fin du fichier soit atteinte + while (!feof(in)) + { + // lit la prochaine paire d'entrées du fichier + get_pol(in,u,v); + + // calcule r et q et imprime dans le fichier de sortie + polynomial_d *r=empty_pol(); + polynomial_d *q=empty_pol(); + + div_euc_o_q(u,v,r,q); + print_pol2(out,r,q); + + // passe à la ligne suivante + ch = getc(in); + } + + // ferme le flux de fichiers d'entrée et de sortie + fclose(out); + fclose(in); + + return 0; +} diff --git a/ntruencrypt/test2.h b/ntruencrypt/test2.h new file mode 100644 index 0000000..fcc7af8 --- /dev/null +++ b/ntruencrypt/test2.h @@ -0,0 +1,6 @@ +#ifndef TEST2_H +#define TEST2_H + + void get_pol(FILE *in, polynomial_d *u, polynomial *v); + +#endif diff --git a/ntruencrypt/test_div_euc_p.txt b/ntruencrypt/test_div_euc_p.txt new file mode 100644 index 0000000..cae5d9a --- /dev/null +++ b/ntruencrypt/test_div_euc_p.txt @@ -0,0 +1,5 @@ + 0 1 1 1 3 1 + 0 1 1 1 + + +