optimisation client / serveur

Bonjour à tous!
alors, voila, j'ai fait un beau programme (j'espère...:mouarf:)
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 :

Code:

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 client.h :

Code:

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;
  }

le serveur.c :

Code:

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);
 
}

et le dernier le serveur.h :

Code:

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;
}

Citation:

Envoyé par Bathou

Bonjour à tous!
alors, voila, j'ai fait un beau programme (j'espère...:mouarf:)
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!!

Je ne m'occupe pas de la partie OPENSSL (que j'ai desactivée dans mon code de test).

bzero() est obsolète. Utiliser memset() ou l'initialisation directe.

concernant la transfert de la taille du fichier, j'avais donné une méthode portable. Que va-t-il se passer si le serveur est sur un Mac et le client sur un PC ?

Si tu ne suis pas les conseils donnés, c'est pas la peine que je me donne du mal pour apporter des corrections.

Bonsoir.

Citation:

Pour être indépendant de l'architecture, il faut définir un format (16-bit, 32-bit), créer un tableau de 2 ou 4 unsigned char et mettre dedans la valeur ocet par octets de façon à transmettre au format réseau (MSB en tête). On fait l'opération inverse en réception. Si ça te parait compliqué (le binaire portable, c'est compliqué), transmet la taille en mode texte, c'est plus simple et très portable.

le truc binaire, j'avais rien compris et comme ça fonctionnait je ne m'en suis pas trop inquiétée.. :aie: bref... pour transmettre la taille en mode texte, si j'ai suivi, il faut utiliser sprintf ou snprintf. par contre, je ne vois pas trop comment8O :
Code:

1 2 char tab[8]; snprintf(tab,8, "%d", taille);
et après dans le send je met le tab...?

je suis un peu perplexe...

Normalement, pour le transfert de données int/short tu dois faire attention à sa représentation en mémoire (little endian/big endian). C'était le sens de la remarque de Emmanuel Delahaye. Normalement, il existe des fonctions pour t'aider: htonl, ntohl, htons, ntohs. Facile à comprendre:
htonl se lit comme h[host]to n[etwork] l[ong]
ntohl se lit alors n[etwork] to h[ost] l[long]
htons se lit comme h[host]to n[etwork] s[hort]
ntohs se lit alors n[etwork] to h[ost] s[hort]
network car la représentation dans le réseau est standardisée.
host pour la représentation dans l'hôte.
Ensuite chacune des fonctions est une conversion réseau vers hôte ou hôte vers réseau déclinée en long et short.

Concrètement cela signifie que tu auras:
Côté émission
Code:

1 2 3 4 5 long taille =fsize(fp); taille = htonl(taille); /* convertion de la représentation host vers la représentation réseau */ longueur=sizeof(taille); int env_taille=send(temp_sock_descriptor, &taille, longueur,0);
Côté réception:
Code:

1 2 3 4 long taille_fichier; recv(sock_descriptor,&taille_fichier,sizeof(taille_fichier),0); taille_fichier = ntohl(taille_fichier); /* convertion de la représentation network vers la représentation host */
A ce moment, tu n'as plus ni a te soucier de la représentation sur l'hôte ni sur ce qui est transmis dans le réseau et c'est portable.

ok, c'est beaucoup plus clair merci !
euh... question stupide... est ce qu'il faut que je le fasses aussi quand je transmet mon fichier...?

Citation:

Envoyé par Bathou

ok, c'est beaucoup plus clair merci !
euh... question stupide... est ce qu'il faut que je le fasses aussi quand je transmet mon fichier...?

Non, les données d"un fichier ne sont pas concernées, car c'est un flux d'octets.

ok merci!
une autre question :aie:
j'ai fait une capture des traces échangées avec Wireshark.
et sur toutes les trames qui correspondent à des envois de données, j'ai TCP CHECKSUM INCORRECT
is it normal...?

Citation:

Envoyé par Bathou

ok merci!
une autre question :aie:
j'ai fait une capture des traces échangées avec Wireshark.
et sur toutes les trames qui correspondent à des envois de données, j'ai TCP CHECKSUM INCORRECT
is it normal...?

Non, mais tu n'y peux pas grand chose, à moins que tu ais de sérieux dépassement de mémoire (mais de là à atteindre les buffers de trames du noyau...)

mince... :(
merci pour ta réponse...