IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Réseau C Discussion :

envoi d'un fichier chiffré, problème au déchiffrement


Sujet :

Réseau C

  1. #1
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut envoi d'un fichier chiffré, problème au déchiffrement
    Bonjour !
    J'ai une errreur que je n'arrive pas à résoudre...
    Je m’explique :
    J’ai deux fichiers : un fichier serveur.c et un fichier client.c le but est que le client qui possède le fichier A chiffre celui-ci dans un fichier B, l’envoie au serveur (on obtient un fichier C)et que le serveur le déchiffre dans un fichier D. (la clé transite en clair au début mais c’est pas important dans l’immédiat, dans le futur elle transitera chiffrée avec du rsa.) donc mon problème est lors du déchiffrement du serveur… Il ne finit pas de déchiffrer…
    Il me met ça comme erreur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    error in decrypt final
    : Success
    3908:error:0606506D:lib(6):func(101):reason(109):evp_enc.c:454:
    Donc soit, j’ai un problème dans ma fonction de déchiffrement (ce qui est bizarre parce qu’elle fonctionne bien quand tout est dans un meme fichier.c. ou alors, je n’envoie pas le fichier correctement via ma connexion TCP…
    Voici mon code :
    coté client pour l'envoi du fichier :
    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
     
        /*ouverture du fichier*/
        fp_source=fopen(FICHIER_ENCRYPT,"r");
        if (fp_source==NULL)
          {
          perror("call to open\n");
          exit(1);
          }
        fseek(fp_source,0,SEEK_SET);
        /*taille du fichier*/
        taille_fichier=fsize(fp_source);
     
        /*envoi de la taille du fichier*/
        if (send(sock_descriptor, &taille_fichier, sizeof (taille_fichier),0)==-1)
            {
            perror("call to send\n");
            exit(1);
            }
        printf("envoi taille fichier ok\n");
     
     
            /*tant qu'on a pas tout envoyé*/
            while ((!feof(fp_source)))/*&&(m<taille_fichier))*/
            {
              /*lecture dans le fichier*/
              fgets(buf,100,fp_source);
     
              /*envoi du contenu du fichier*/
              if (((send(sock_descriptor, &buf, sizeof(buf),0)))==-1)
                {
                perror("call to send\n");
                exit(1);
                }
     
              /*remise à zéro du buffer*/
              bzero(&buf,sizeof(buf));
            }
     
            printf("envoi effectué\n");
    coté serveur la réception du-dit fichier :
    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
     
      /*ouverture du fichier résultat*/
      fp_resultat=fopen(FICHIER_ENCRYPT,"wb");
      if (fp_resultat==NULL)
          {
          perror("call to open\n");
          exit(1);
          }
     
     
     
     
          while (taille_fichier>=0)
            {
            /*réception du fichier*/
            if (recv(temp_sock_descriptor,&buf,sizeof(buf),0)==-1)
              {
              perror("call to rcv\n");
              exit(1);
              }
            while ((buf[i]!='\n'))/*|(i<(sizeof(buf)))*/
              {
              i=i+1;
              }
     
            taille_buf=i;
     
            /*écriture dans le fichier résultat*/
            fputs(buf,fp_resultat);
            /*diminue la taille*/
            taille_fichier=taille_fichier-taille_buf;
            taille_buf=0;
            i=0;
     
            bzero(&buf,sizeof(buf));/*remise à zéro du buffeur*/
            }
            fputs("EOF",fp_resultat);
          /*fermeture du fichier*/
          fclose(fp_resultat);
          printf("reception ok\n");
    et enfin coté serveur : l'appel de ma fonction decrypt :
    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
     
     
    int flags1 = 0, flags2 = 0, outfd, infd, decfd;
      mode_t mode;
    	bzero (&mode, sizeof (mode));
     
    	flags1 = flags1 | O_RDONLY;
    	flags2 = flags2 | O_RDONLY;
    	flags2 = flags2 | O_WRONLY;
    	flags2 = flags2 | O_CREAT;
     
    	mode = mode | S_IRUSR;
    	mode = mode | S_IWUSR;
     
     
     if ((outfd = open (FICHIER_ENCRYPT, flags1, mode )) == -1)
    				    perror ("open output file error");
     
    			    if ((decfd = open (FICHIER_DEC, flags2, mode)) == -1)
    				    perror ("open output file error");
     
    			    decrypt (outfd, decfd);
     
    			    close (outfd);
    			    fsync (decfd);
    			    close (decfd);
    			    printf("the file is decrypt\n\n");
    et enfin, la fameuse fonction decrypt :
    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
     
    int decrypt (int infd, int outfd)
    {
    	unsigned char outbuf[IP_SIZE];
    	int olen, tlen, n;
    	char inbuff[OP_SIZE];
    	EVP_CIPHER_CTX ctx;
    	EVP_CIPHER_CTX_init (&ctx);
    	EVP_DecryptInit (&ctx, EVP_bf_cbc (), key, iv);
     
    	for (;;)
    	  {
    		  bzero (&inbuff, OP_SIZE);
    		  if ((n = read (infd, inbuff, OP_SIZE)) == -1)
    		    {
    			    perror ("read error");
    			    break;
    		    }
    		  else if (n == 0)
    			  break;
     
    		  bzero (&outbuf, IP_SIZE);
     
    		  if (EVP_DecryptUpdate (&ctx, outbuf, &olen, inbuff, n) != 1)
    		    {
    			    printf ("error in decrypt update\n");
    			    return 0;
    		    }
     
    		  if (EVP_DecryptFinal (&ctx, outbuf + olen, &tlen) != 1)
    		    {
    			    perror("error in decrypt final\n");
    				ERR_print_errors_fp(stderr);
     
    			    return 0;
    		    }
    		  olen += tlen;
    		  if ((n = write (outfd, outbuf, olen)) == -1)
    			  perror ("write error");
    	  }
     
    	EVP_CIPHER_CTX_cleanup (&ctx);
    	return 1;
    }
    voila, encore deux précisions : j'utilise l'algo blowfish avec la librairie d'openSSL et je suis sous Redhat.

    merci d'avance pour votre aide!!

  2. #2
    Rédacteur

    Avatar de ram-0000
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    Mai 2007
    Messages
    11 517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Mai 2007
    Messages : 11 517
    Par défaut
    Quelques remarques:

    Remarque 1: dans le code du client pour l'envoi du fichier
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
              /*lecture dans le fichier*/
              fgets(buf,100,fp_source);
     
              /*envoi du contenu du fichier*/
              if (((send(sock_descriptor, &buf, sizeof(buf),0)))==-1)
    On ne voit pas la variable buf (mais c'est pas grave, je suppose qu'elle existe) par contre, si elle ne fait pas exactement 100 octetc, tu as un problème.

    J'écrirai plutôt:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
              /*lecture dans le fichier*/
              fgets(buf,sizeof(buf),fp_source);
     
              /*envoi du contenu du fichier*/
              if (((send(sock_descriptor, &buf, sizeof(buf),0)))==-1)
    Remarque 2: dans le code du client on voit que tu envoies la taille du fichier en premier par contre dans le code du serveur, on ne voie pas la lecture de cette taille. Un oubli de ta part ?

    Remarque 3 : dans le code du client, tu ouvres le fichier en mode texte. Comme a priori c'est un fichier encrypté, tu devrais l'ouvrir en binaire (d'ailleurs tu le créés en binaire dans la partie serveur)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    /*ouverture du fichier*/
    fp_source=fopen(FICHIER_ENCRYPT,"r");

    Remarque 4 : c'est quoi cette écriture de "EOF" en fin de fichier
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    fputs("EOF",fp_resultat);
    Je pense que tu peux supprimer cette ligne et faire le fclose directement.
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

  3. #3
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    toutes mes confuses pour les quelques problèmes qui trainent...
    R1 : j'ai changé selon tes conseils
    R2 : j'ai oublié de poster le code mais ça y est!
    R3 : j'avais changé des deux cotés pour voir si ca marchait pas mieux et j'ai oublié de rectifier coté client...
    R4 : une idée stupide qui (encore) traine...


    hélas, ca ne fonctionne toujours pas...

  4. #4
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    1/fgets(buf,100,fp_source) ne te garantie pas que tu vas lire 100 octets et send(sock_descriptor, &buf, sizeof(buf),0) va envoyé la taille de buf et non 100 octets. Si par exemple, tu as défini char*buf, ca ne marche pas.
    Je passerais plutôt par OctetsLus = fread(), puis send(OctetsLus)
    2/recv(temp_sock_descriptor,&buf,sizeof(buf),0): idem. Tu devrais te baser sur le nombre d'octets lus retournés plutôt que sur la taille de ton buffer.
    3/Tu utilises tes données comme si c'était du mode texte alors qu'à priori ce serait plutôt du binaire.

  5. #5
    Rédacteur

    Avatar de ram-0000
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    Mai 2007
    Messages
    11 517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Mai 2007
    Messages : 11 517
    Par défaut
    Une question, est ce que le fichier reçu par le serveur est rigiureusement identique au fichier émis par le client (taille, checksum, md5, etc).

    Tant qu'ils ne sont pas identiques, ce n'est même pas la peine de regarder la fonction décrypte(), elle ne fonctionnera pas.
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

  6. #6
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    c'est ce que je regardais : mes fichiers ne sont pas identiques... j'ai le début et la fin de pareil mais pas le milieu... étrange...

    je n'ai pas compris la remarque 2 de 3DArchi...

  7. #7
    Rédacteur

    Avatar de ram-0000
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    Mai 2007
    Messages
    11 517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Mai 2007
    Messages : 11 517
    Par défaut
    Citation Envoyé par Bathou Voir le message
    je n'ai pas compris la remarque 2 de 3DArchi...
    Il veut dire dans le code de réception du fichier quelque chose comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
            /*réception du fichier*/
            int nb_recv = recv(temp_sock_descriptor,&buf,sizeof(buf),0);
            if(nb_recv == -1)
              {
              perror("call to rcv\n");
              exit(1);
              }
     
            /* ecriture dans le fichier (traitement d'erreur à faire) */
            write(fp_resultat, buf, nb_recv);
    Par contre, je ne comprend pas l'intérêt de ce bout de code dans la partie réception
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
            while ((buf[i]!='\n'))/*|(i<(sizeof(buf)))*/
              {
              i=i+1;
              }
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

  8. #8
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    ok
    aucune idée, je me souviens pu pourquoi j'ai tapé ca... ca devais avoir une utilisation... surement lol
    je l'ai enlevé et j'ai mis ca

  9. #9
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    alors, j'ai changé en ce qu'avait dit 3DArchi
    et euh... il ne recopie plus rien de mon fichier de réception...

  10. #10
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par Bathou Voir le message
    ou alors, je n’envoie pas le fichier correctement via ma connexion TCP…
    Il faut commencer par ça...
    Voici mon code :
    coté client pour l'envoi du fichier :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
        /*envoi de la taille du fichier*/
        if (send(sock_descriptor, &taille_fichier, sizeof (taille_fichier),0)==-1)
    Horriblement pas portable. 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.

    (sprintf()) -> sscanf() ou strtoul())
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
            /*tant qu'on a pas tout envoyé*/
            while ((!feof(fp_source)))/*&&(m<taille_fichier))*/
    feof() ne fait pas ce que tu crois. Il faut utiliser la valeur retournée par la fonction de lecture (en supposant que buf est un tableau de 100 char) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
           /*lecture dans le fichier*/
           while (fgets(buf,sizeof buf,fp_source) != NULL)
           {
    tu es certain que le fichier est texte ? fgets() n'a de sens que sur un fichier texte.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
              /*envoi du contenu du fichier*/
              if (((send(sock_descriptor, &buf, sizeof(buf),0)))==-1)
    Très suspect.
    • Pourquoi &buf ? C'est buf.
    • Pourquoi sizeof buf ? Tu vas transmettre un tas de 0 en plus des données...

    Si c'est du texte, c'est strlen(buf) et rien d'autre.

    coté serveur la réception du-dit fichier :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
      /*ouverture du fichier résultat*/
      fp_resultat=fopen(FICHIER_ENCRYPT,"wb");
    Je comprend rien. C'est du texte ou du binaire ? Si c'est du binaire le code du dessus est complètement faux.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
          while (taille_fichier>=0)
            {
            /*réception du fichier*/
            if (recv(temp_sock_descriptor,&buf,sizeof(buf),0)==-1)
              {
              perror("call to rcv\n");
              exit(1);
              }
            while ((buf[i]!='\n'))/*|(i<(sizeof(buf)))*/
              {
              i=i+1;
              }
    Mais qu'est-ce que c'est que cette usine à gaz... tu ne sais que recv() renvoie le nombre de caractères reçus ?

    La transmission de données, c'est beaucoup plus simple que ça.

    Transmission d'un texte :

    http://emmanuel-delahaye.developpez....eaux.htm#texte

    (et je rappelle que le mode d'ouverture 'texte' est "r" et "w").

    Transmission de données binaires :
    (on suppose que les infos du ficher ont été déjà transmises : nom, taille, date, droits etc.)

    Emission :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    unsigned char data[1024];
    int n;
    while ((n = fread(data, 1, sizeof data, fp)) > 0)
    {
       send (sock, data, n, 0);
    }
    fclose (fp);
    En réception :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    /* nb = nombre d'octets à recevoir */
     
    unsigned char data[1024];
    int n;
    while (nb > 0 && (n = recv(sock, data, sizeof data, 0)) > 0)
    {
       fwrite(data, 1, n, fp);
       nb -= n;
    }
    fclose (fp);
    NON TESTE

  11. #11
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    bonjour
    donc j'ai changé ce qui n'allait pas : le feof c'et bon, j'ai compris ^^ merci
    donc pour le moment, j'ai fait une transmision de fichiers texte et ca a l'air de marcher à priori...
    je poste mon code pour avoir votre avis si j'ai encore des anneries qui trainent... merci... ensuite je m'attaque à la transimission de fichier binaire et je réinsère mon chiffrement pour voir si ca marche...
    voila pour le client :
    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
    /* Program client */
     
    #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>
     
    #define fichier "fichier_emis.txt"
     
     
    int port = 12345;
     
    long fsize(FILE*fp);
     
     
    //////////////////////////////////////////////////////////////////
    //								//
    //			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;
      }
     
     
    //////////////////////////////////////////////////////////////////ss
    //								//
    //			Fonction Principale			//
    //								//
    //////////////////////////////////////////////////////////////////
    int main(int argc,char *argv[])
     
    {
     
      /*DECLARATION DES STRUCTURES ET DES VARIABLES*/
      struct sockaddr_in to;
      int sock_descriptor;
      int temp_sock_descriptor;
      FILE*fp_emis;
      int longueur=0;
      char buf[300];
     
      /*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");
     
     
    /*ouverture du fichier*/
      fp_emis=fopen(fichier,"r");
      if (fp_emis==NULL)
            {
            perror("call to open\n");
            exit(1);
            }
     
      /*envoi de la taille du fichier*/
      int taille =fsize(fp_emis);
      longueur=sizeof(taille);
      int env_taille=send(sock_descriptor, &taille, longueur,0);
      if (env_taille==-1)
            {
            perror("call to send\n");
            exit(1);
            }
          printf("envoi ok\n");
     
     
     
      /*tant qu'on n'a pas tout envoyé, tant qu'on n'a pas atteint la fin du fichier*/
      fseek(fp_emis,0,SEEK_SET);
      while (fgets(buf,sizeof buf,fp_emis)!= NULL)
        {
     
        /*on envoi*/
        int envoi=send(sock_descriptor, buf, strlen(buf),0);
        if (envoi==-1)
          {
          perror("call to send\n");
          exit(1);
          }
    printf("envoi paquet\n");
     
        }
      /*si une erreur s'est produite*/
     /* if (ferror(fp_emis))
        {
        /* out */
       /* perror (fichier);
        }
     
     
     
      /*fermeture du fichier*/
      fclose(fp_emis);
     
     
     
    /*close*/
    close(temp_sock_descriptor);
    exit(0);
     
    }
    et pour le serveur :
    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
    /* Program server */
     
    #include <errno.h>
     
    #include <stdlib.h>
     
    #include <string.h>
     
    #include <stdio.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <netdb.h>
     
    #define fichier "fichier_recu.txt"
     
     
    int port = 12345;
     
    int main(int argc,char *argv[])
     
    {
     
      /*Déclaration des structures et des variables*/
      struct sockaddr_in sin;
      struct sockaddr_in pin;
      int sock_descriptor;
      int temp_sock_descriptor;
      int address_size;
      char buf[300];
      FILE*fp_recu;
      int taille_fichier=0;
     
      /*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)
        {
     
        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");
     
        /*ouverture du fichier*/
        fp_recu=fopen(fichier,"w");
        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("taille fichier %d reçue\n",taille_fichier);
      printf("Reception fichier en cours...\n");
     
      /*tant que l'on a pas tout reçu*/
      while(taille_fichier>0)
        {
        /*on recoi*/
        int recp_fich = recv(temp_sock_descriptor,buf,sizeof(buf),0);
        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=taille_fichier-recp_fich;
        //taille_buf=0;
    	bzero(&buf,sizeof(buf));
        }
      /*fermeture du fichier*/
      fclose(fp_recu);
      }
     
     
    /*close*/
    close(temp_sock_descriptor);
    exit(0);
     
    }
    merci pour votre aide...

  12. #12
    Membre confirmé Avatar de Bathou
    Inscrit en
    Mars 2007
    Messages
    179
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mars 2007
    Messages : 179
    Par défaut
    j'ai réessayé de chiffrer avec le code que je viens de mettre plus haut...(j'espère qu'il est pas foireux...)
    et j'obtiens cette erreur la :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    error in decrypt final
    : Invalid or incomplete multibyte or wide character
    23924:error:0606506D:lib(6):func(101):reason(109):evp_enc.c:454:
    je pense que c'est toujours mon fichier qui n'est pas correctement envoyé, recu... peut etre que comme il est codé je ne devrais pas le mettre en fichier texte...
    si quelqu'un avait la bonté de m'éclairer...
    merci...

    [EDIT] : c'est bon ca marche, j'ai mis les fichiers chiffrés dans des fichiers binaires. et j'ai fait comme Emmanuel avait mis à la fin de son poste
    merci à ceux qui m'ont aidé!

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Problème envoi d'un fichier par email
    Par Hellgast dans le forum Réseau
    Réponses: 8
    Dernier message: 19/09/2009, 23h59
  2. Réponses: 0
    Dernier message: 15/03/2009, 22h07
  3. Réponses: 0
    Dernier message: 29/11/2007, 12h28
  4. Réponses: 1
    Dernier message: 22/08/2007, 09h38
  5. Réponses: 5
    Dernier message: 03/04/2007, 16h11

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo