Bonjour à tous!
alors, voila, j'ai fait un beau programme (j'espère...)
et je voudrai savoir si je peux l'améliorer, c'est à dire si j'utilise bien les fonctions etc... genre que je ne bourrine pas alors qu'il y a plus simple...
bref toutes les suggestions sont les bienvenues!!
merci par avance pour votre aide, je met mon code :
le client.c :
le client.h :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199 /* Program client */ #include "client.h" ////////////////////////////////////////////////////////////////// // // // Fonction Principale // // // ////////////////////////////////////////////////////////////////// int main(int argc,char *argv[]) { /*DECLARATION DES STRUCTURES ET DES VARIABLES*/ struct sockaddr_in to; int sock_descriptor; FILE*fp_recu,*fp_enc,*fpin=NULL,*fpout=NULL; int longueur=0; char buf[300]; int n=0,taille_fichier=0,recp_fich; unsigned char *cipher=NULL,*plain=NULL; int size=0,len=0,ks=0; RSA *key=NULL; //////////////////////////////////////////////////////////////// /*CREATION DE LA SOCKET*/ sock_descriptor = socket(AF_INET, SOCK_STREAM, 0); if (sock_descriptor ==-1) { perror("call to socket\n"); exit(1); } printf("socket ok\n"); /**/ bzero(&to,sizeof(to)); to.sin_family=AF_INET; to.sin_addr.s_addr=inet_addr("10.102.13.114"); to.sin_port=htons(port); printf("connexion wait...\n"); /*CONNEXION*/ if (connect(sock_descriptor, (struct sockaddr*)&to, sizeof(to))==-1) { perror("call to connect\n"); exit(1); } printf("connect ok\n"); //////////////////////////////////////////////////////////////// /*RECEPTION DE LA CLE PUBLIQUE*/ /*ouverture du fichier*/ fp_recu=fopen(FICHIER,"wb"); if (fp_recu==NULL) { perror("call to open\n"); exit(1); } /*reception de la taille du fichier*/ int recp_taille=recv(sock_descriptor,&taille_fichier,sizeof(taille_fichier),0); if (recp_taille==-1) { perror("call to rcv taille\n"); exit(1); } printf("file size %d receive\n",taille_fichier); printf("Reception...\n"); /*tant que l'on a pas tout reçu*/ while (taille_fichier > 0 && (recp_fich = recv(sock_descriptor, buf, sizeof (buf), 0)) > 0) { /*on recoi*/ if(recp_fich <0) { perror("call to rcv\n"); exit(1); } /*on écrit dans le fichier*/ fwrite(buf,1,recp_fich,fp_recu); /*on diminue la taille*/ taille_fichier -= recp_fich; /*RAZ du buffer*/ bzero(&buf,sizeof(buf)); } /*fermeture du fichier*/ fclose(fp_recu); //////////////////////////////////////////////////////////////// /*CHIFFREMENT DU FICHIER*/ /*lecture de la clé publique*/ key = readpemkeys(READPUB); /*ouverture du fichier input*/ if(!(fpin = fopen(FICHIER_CLAIR, "rb"))) { fprintf(stderr, "Error: Cannot locate input file.\n"); exit(EXIT_FAILURE); } /*ouverture du fichier output*/ fpout = fopen(FICHIER_ENC, "wb"); /*taille de la clé*/ ks = RSA_size(key); /*allocation ed mémoire*/ plain = (unsigned char *)malloc(ks * sizeof(unsigned char)); cipher = (unsigned char*)malloc(ks * sizeof(unsigned char)); printf("Encrypting '%s' file.\n",FICHIER_CLAIR); /*tant qu'on a pas atteint la fin du fichier input*/ while(!feof(fpin)) { /*remise à zéro de plain et cipher*/ memset(plain,'\0',ks + 1); memset(cipher, '\0', ks + 1); /*lecture dans le fichier input*/ len = fread(plain, 1, ks - 11, fpin); /*chiffrement avec Rsa*/ size = rsa_encrypt(key, plain, len, &cipher); /*écriture dans le fichier d'arrivée*/ fwrite(cipher, 1, size, fpout); } /*fermeture des deux fichiers*/ fclose(fpout); fclose(fpin); /*libération de la mémoire*/ free(cipher); free(plain); RSA_free(key); printf("Done.\n"); //////////////////////////////////////////////////////////////// /*ENVOI DU-DIT FICHIER*/ /*ouverture du fichier*/ fp_enc=fopen(FICHIER_ENC,"rb"); if (fp_enc==NULL) { perror("call to open\n"); exit(1); } /*envoi de la taille du fichier*/ int taille =fsize(fp_enc); longueur=sizeof(taille); int env_taille=send(sock_descriptor, &taille, longueur,0); if (env_taille==-1) { perror("call to send\n"); exit(1); } printf("send ok\n"); /*tant qu'on n'a pas tout envoyé, tant qu'on n'a pas atteint la fin du fichier*/ fseek(fp_enc,0,SEEK_SET); while ((n = fread(buf, 1, sizeof(buf), fp_enc)) > 0) { /*on envoi*/ int envoi=send(sock_descriptor, buf, n,0); if (envoi==-1) { perror("call to send\n"); exit(1); } } /*fermeture du fichier*/ fclose(fp_enc); /*close*/ close(sock_descriptor); exit(0); }
le serveur.c :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148 /*Headers*/ #include "errno.h" #include "stdlib.h" #include "string.h" #include "stdio.h" #include "sys/socket.h" #include "netinet/in.h" #include "arpa/inet.h" #include "netdb.h" #include "sys/types.h" #include "fcntl.h" #include "sys/stat.h" #include "unistd.h" /*OpenSSL headers*/ #include "openssl/ssl.h" #include "openssl/bio.h" #include "openssl/err.h" #include "openssl/evp.h" #include "openssl/rsa.h" #define READPUB 0 #define READSEC 1 int port = 12345; #define FICHIER "cle_publique.pem" #define FICHIER_CLAIR "fichier_clair.txt" #define FICHIER_ENC "fichier_encode.bin" RSA* readpemkeys(int type); int rsa_encrypt(RSA *key, unsigned char *plain, int len, unsigned char **cipher); long fsize(FILE*fp); ////////////////////////////////////////////////////////////////// // // // read PEM keys function // // // ////////////////////////////////////////////////////////////////// RSA* readpemkeys(int type) { FILE *fp; RSA *key=NULL; //////////////////////////////////////////////////////////////// /*si clé publique*/ if(type == READPUB) { /*ouverture du fichier*/ if((fp = fopen(FICHIER,"r")) == NULL) { fprintf(stderr,"Error: Public Key file doesn't exists.\n"); exit(EXIT_FAILURE); } /*lecture de la clé publique*/ if((key = PEM_read_RSAPublicKey(fp,NULL,NULL,NULL)) == NULL) { fprintf(stderr,"Error: problems while reading Public Key.\n"); exit(EXIT_FAILURE); } /*fermeture du fichier*/ fclose(fp); /*retourne la valeur de la clé lue*/ return key; } //////////////////////////////////////////////////////////////// /*si clé privée*/ // if(type == READSEC) // { /*ouverture du fichier*/ // if((fp = fopen(SECFILE,"r")) == NULL) // { // fprintf(stderr,"Error: Private Key file doesn't exists.\n"); // exit(EXIT_FAILURE); // } /*lecture de la clé privée*/ // if((key = PEM_read_RSAPrivateKey(fp,NULL,NULL,NULL)) == NULL) // { // fprintf(stderr,"Error: problmes while reading Private Key.\n"); // exit(EXIT_FAILURE); // } /*fermeture du fichier*/ // fclose(fp); /*verification de la clé*/ /*si =-1 échou*/ // if(RSA_check_key(key) == -1) // { // fprintf(stderr,"Error: Problems while reading RSA Private Key in '%s' file.\n",SECFILE); // exit(EXIT_FAILURE); // } /*si =0 échec*/ // else if(RSA_check_key(key) == 0) // { // fprintf(stderr,"Error: Bad RSA Private Key readed in '%s' file.\n",SECFILE); // exit(EXIT_FAILURE); // } // else/*on retourne la clé*/ // return key; // } return key; } ////////////////////////////////////////////////////////////////// // // // RSA Encrypt Function // // // ////////////////////////////////////////////////////////////////// int rsa_encrypt(RSA *key, unsigned char *plain, int len, unsigned char **cipher) { int clen=0; /*nombrea aléatoire*/ srand(time(NULL)); /*on chiffre*/ if((clen = RSA_public_encrypt(len, plain, *cipher, key, RSA_PKCS1_PADDING)) == -1) { fprintf(stderr, "%s\n", ERR_error_string(ERR_get_error(), NULL)); exit(EXIT_FAILURE); } else return clen; } ////////////////////////////////////////////////////////////////// // // // function Fsize // // // ////////////////////////////////////////////////////////////////// long fsize(FILE*fp) { long pos,size; pos=ftell(fp); /*sauve la position courante*/ fseek(fp,0,SEEK_END);/*aller en fin*/ size=ftell(fp);/*lire la taille*/ fseek(fp,pos,SEEK_SET);/*revenir à la position initiale*/ return size; }
et le dernier le serveur.h :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235 /* Program serveur */ #include "serveur.h" ////////////////////////////////////////////////////////////////// // // // Fonction Principale // // // ////////////////////////////////////////////////////////////////// int main(int argc,char *argv[]) { /*Déclaration des structures et des variables*/ struct sockaddr_in sin; struct sockaddr_in pin; int sock_descriptor,temp_sock_descriptor; int address_size; char buf[300]; FILE*fp,*fp_recu,*fpin,*fpout; int taille_fichier=0,recp_fich=0,ks=0,longueur=0,n=0; unsigned char *cipher=NULL,*plain=NULL; int size=0,len=0; RSA *key=NULL; //////////////////////////////////////////////////////////////// /*CREATION DE LA SOCKET*/ sock_descriptor = socket(AF_INET, SOCK_STREAM, 0); if (sock_descriptor ==-1) { perror("call to socket\n"); exit(1); } printf("socket ok\n"); /*initialisation*/ bzero(&sin,sizeof(sin)); sin.sin_family=AF_INET; sin.sin_addr.s_addr=INADDR_ANY; sin.sin_port=htons(port); /*BIND*/ if (bind(sock_descriptor, (struct sockaddr*)&sin, sizeof(sin))==-1) { perror("call to bind\n"); exit(1); } printf("bind ok\n"); /*LISTEN*/ if (listen(sock_descriptor, 20)==-1) { perror("call to listen\n"); exit(1); } while(1) { /*ACCEPT*/ printf("Accepting connections...\n"); address_size=sizeof(struct sockaddr_in); if ((temp_sock_descriptor=accept(sock_descriptor, (struct sockaddr *)&pin, &address_size))==-1) { perror("call to accept\n"); exit(1); } printf("accept ok\n"); ////////////////////////////////////////////////////////////////// /*GENERATION DE LA CLE*/ /*taille de la clé*/ ks = 1024; printf("Generating RSA keys [size = %d bits]\n", ks); /*appel de la fonction de génération des clés*/ genkey(ks); /*affichage des fichiers contenant clé privée et clé publique*/ printf("Private Key saved in %s file.\n", SECFILE); printf("Public Key saved in %s file.\n", PUBFILE); printf("Done.\n"); ////////////////////////////////////////////////////////////////// /*ENVOI DE LA CLE PUBLIQUE*/ /*ouverture du fichier*/ fp=fopen(PUBFILE,"rb"); if (fp==NULL) { perror("call to open\n"); exit(1); } /*envoi de la taille du fichier*/ int taille =fsize(fp); longueur=sizeof(taille); int env_taille=send(temp_sock_descriptor, &taille, longueur,0); if (env_taille==-1) { perror("call to send\n"); exit(1); } printf("send file size ok\n"); /*tant qu'on n'a pas tout envoyé, tant qu'on n'a pas atteint la fin du fichier*/ fseek(fp,0,SEEK_SET); while ((n = fread(buf, 1, sizeof(buf), fp)) > 0) { /*on envoi*/ int envoi=send(temp_sock_descriptor, buf, n,0); if (envoi==-1) { perror("call to send\n"); exit(1); } } /*fermeture du fichier*/ fclose(fp); ////////////////////////////////////////////////////////////////// /*RECEPTION DU FICHIER CHIFFRE*/ /*ouverture du fichier*/ fp_recu=fopen(FICHIER_ENC,"wb"); if (fp_recu==NULL) { perror("call to open\n"); exit(1); } /*reception de la taille du fichier*/ int recp_taille=recv(temp_sock_descriptor,&taille_fichier,sizeof(taille_fichier),0); if (recp_taille==-1) { perror("call to rcv taille\n"); exit(1); } printf("size file %d receive\n",taille_fichier); printf("Reception ...\n"); /*tant que l'on a pas tout reçu*/ while (taille_fichier > 0 && (recp_fich = recv(temp_sock_descriptor, buf, sizeof (buf), 0)) > 0) { /*on recoi*/ if(recp_fich <0) { perror("call to rcv\n"); exit(1); } /*on écrit dans le fichier*/ fwrite(buf,1,recp_fich,fp_recu); /*on diminue la taille*/ taille_fichier -= recp_fich; /*RAZ buffer*/ bzero(&buf,sizeof(buf)); } /*fermeture du fichier*/ fclose(fp_recu); printf("reception OK!\n"); ////////////////////////////////////////////////////////////////// /*DECHIFFREMENT DU-DIT FICHIER*/ /*lecture de la clé privée*/ key = readpemkeys(READSEC); /*ouverture du fichier input*/ if(!(fpin = fopen(FICHIER_ENC, "rb"))) { fprintf(stderr, "Error: Cannot locate input file.\n"); exit(EXIT_FAILURE); } /*ouverture du fichier output*/ fpout = fopen(FICHIER, "wb"); /*taille de la clé rsa*/ ks = RSA_size(key); /*allocation de la mémoire*/ cipher = (unsigned char*)malloc(ks * sizeof(unsigned char)); plain = (unsigned char*)malloc(ks * sizeof(unsigned char)); printf("Decrypting '%s' file.\n", FICHIER_ENC); /*tant qu'on n'a pas atteint la fin du fichier*/ while(!feof(fpin)) { /*mise à zéro de cipher et plain*/ memset(cipher, '\0', ks); memset(plain, '\0', ks); /*lecture de l'info dans le fichier input*/ if ((len = fread(cipher, 1, ks, fpin)) == 0) break; /*déchiffrement*/ size = rsa_decrypt(key, cipher, len, &plain); /*écriture dans le fichier out put*/ fwrite(plain, 1, size, fpout); } /*fermeture des fichiers*/ fclose(fpout); fclose(fpin); /*libération de la mémoire*/ free(plain); free(cipher); RSA_free(key); printf("Done.\n"); } /*close*/ close(temp_sock_descriptor); exit(0); }
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214 /*Headers*/ #include "errno.h" #include "stdlib.h" #include "string.h" #include "stdio.h" #include "sys/socket.h" #include "netinet/in.h" #include "arpa/inet.h" #include "netdb.h" #include "sys/types.h" #include "fcntl.h" #include "sys/stat.h" #include "unistd.h" /*OpenSSL headers*/ #include "openssl/ssl.h" #include "openssl/bio.h" #include "openssl/err.h" #include "openssl/evp.h" #include "openssl/rsa.h" #define READPUB 0 #define READSEC 1 /*fichiers PEM pour clés publiques/privées*/ #define SECFILE "sec.pem" #define PUBFILE "pub.pem" #define FICHIER_ENC "fichier_chiffre_recu.bin" #define FICHIER "fichier_dec.txt" int port = 12345; void genkey(int size); long fsize(FILE*fp); int rsa_decrypt(RSA *key, unsigned char *cipher, int len, unsigned char **plain); RSA* readpemkeys(int type); ////////////////////////////////////////////////////////////////// // // // GenerationKey fonction // // // ////////////////////////////////////////////////////////////////// void genkey(int size) { RSA *key=NULL; FILE *fp; //////////////////////////////////////////////////////////////// /*génération de la clé*/ if((key = RSA_generate_key(size,3,NULL,NULL)) == NULL) { fprintf(stderr,"%s\n",ERR_error_string(ERR_get_error(),NULL)); exit(EXIT_FAILURE); } /*vérification de la clé*/ if(RSA_check_key(key) < 1) { fprintf(stderr,"Error: Problems while generating RSA Key.\nRetry.\n"); exit(EXIT_FAILURE); } //////////////////////////////////////////////////////////////// /*CLE PRIVEE*/ /*ouverture du fichier de clé privée*/ fp=fopen(SECFILE,"wb"); /*écriture de la clé privée dans son fichier*/ if(PEM_write_RSAPrivateKey(fp,key,NULL,NULL,0,0,NULL) == 0) { fprintf(stderr,"Error: problems while writing RSA Private Key.\n"); exit(EXIT_FAILURE); } /*fermeture du fichier*/ fclose(fp); //////////////////////////////////////////////////////////////// /*CLE PUBLIQUE*/ /*ouverture du fichier de clé publique*/ fp=fopen(PUBFILE,"wb"); /*écriture de la clé publique dans son fichier*/ if(PEM_write_RSAPublicKey(fp,key) == 0) { fprintf(stderr,"Error: problems while writing RSA Public Key.\n"); exit(EXIT_FAILURE); } /*fermeture du fichier*/ fclose(fp); /////////////////////////////////////////////////////////////// /*libération de la mémoire pour le contexte RSA*/ RSA_free(key); return; } ////////////////////////////////////////////////////////////////// // // // fonction Fsize // // // ////////////////////////////////////////////////////////////////// long fsize(FILE*fp) { long pos,size; pos=ftell(fp); /*sauve la position courante*/ fseek(fp,0,SEEK_END);/*aller en fin*/ size=ftell(fp);/*lire la taille*/ fseek(fp,pos,SEEK_SET);/*revenir à la position initiale*/ return size; } ////////////////////////////////////////////////////////////////// // // // RSA Decrypt Function // // // ////////////////////////////////////////////////////////////////// int rsa_decrypt(RSA *key, unsigned char *cipher, int len, unsigned char **plain) { int plen=0; /*on déchiffre*/ if((plen = RSA_private_decrypt(len, cipher, *plain, key, RSA_PKCS1_PADDING)) == -1) { fprintf(stderr, "%s\n", ERR_error_string(ERR_get_error(), NULL)); exit(EXIT_FAILURE); } else return plen; } ////////////////////////////////////////////////////////////////// // // // read PEM keys function // // // ////////////////////////////////////////////////////////////////// RSA* readpemkeys(int type) { FILE *fp; RSA *key=NULL; //////////////////////////////////////////////////////////////// /*si clé publique*/ if(type == READPUB) { /*ouverture du fichier*/ if((fp = fopen(PUBFILE,"r")) == NULL) { fprintf(stderr,"Error: Public Key file doesn't exists.\n"); exit(EXIT_FAILURE); } /*lecture de la clé publique*/ if((key = PEM_read_RSAPublicKey(fp,NULL,NULL,NULL)) == NULL) { fprintf(stderr,"Error: problems while reading Public Key.\n"); exit(EXIT_FAILURE); } /*fermeture du fichier*/ fclose(fp); /*retourne la valeur de la clé lue*/ return key; } //////////////////////////////////////////////////////////////// /*si clé privée*/ if(type == READSEC) { /*ouverture du fichier*/ if((fp = fopen(SECFILE,"r")) == NULL) { fprintf(stderr,"Error: Private Key file doesn't exists.\n"); exit(EXIT_FAILURE); } /*lecture de la clé privée*/ if((key = PEM_read_RSAPrivateKey(fp,NULL,NULL,NULL)) == NULL) { fprintf(stderr,"Error: problmes while reading Private Key.\n"); exit(EXIT_FAILURE); } /*fermeture du fichier*/ fclose(fp); /*verification de la clé*/ /*si =-1 échou*/ if(RSA_check_key(key) == -1) { fprintf(stderr,"Error: Problems while reading RSA Private Key in '%s' file.\n",SECFILE); exit(EXIT_FAILURE); } /*si =0 échec*/ else if(RSA_check_key(key) == 0) { fprintf(stderr,"Error: Bad RSA Private Key readed in '%s' file.\n",SECFILE); exit(EXIT_FAILURE); } else/*on retourne la clé*/ return key; } return key; }
Partager