/Documents/c/encrypt # cat crypt.c
#define _GNU_SOURCE

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <rpc/des_crypt.h>

/*
**
** ce source est destiner a fournir un petit outil
** d'encryption/decription de fichier par clef sur
** le protocole d'encryptage DES
**
** voir a la fin de ce fichier la methode de compilation
** specifique = (1 binaire 2 executables_links 1 source)
**
*/

int main(int argc, char * argv[])
{
        char *          nom_programme ;
        //choisir de crypter ou decripter (1 source = 2 programmes ! )
        //en realite 1 programme dont le comportement differe si
        //il est nome des_decrypt ou des_encrypt
        //suffit de faire des liens nomes ainsi vers
        //l'executable et ca devrai marcher....
        //penser a compiler avec la commande make et rien d'autre !!!
        int             fichier ;
        struct stat     etat_fichier;
        long            taille_fichier ; //attention aux limites de taille
        char *          projection ; // pour effectuer la projection du fichier dans la ram
        char            cle[8];
        unsigned        mode; //pour gerer le fichier
        int             retour;
        // gerer les erreurs
        if (argc != 3)
        {
                fprintf(stderr,"\n\tUsage %s : fichier clef (de 8!)\n",argv[0]);
                exit(EXIT_FAILURE);
        }
        // celle de l'utilisateur d'abord....
        if ((fichier = open(argv[1],O_RDWR)) < 0)
        {
                perror("open");
                exit(EXIT_FAILURE);
        } // fichier inouvrable
        if (stat(argv[1], & etat_fichier ) != 0)
        {
                perror("stat");
                exit(EXIT_FAILURE);
        }
        // voila pour les principaux risque de soucis
        nom_programme=basename(argv[0]);
        if(strcasecmp(nom_programme,"des_decrypt") == 0)
                mode = DES_DECRYPT ;
        else
                mode = DES_ENCRYPT ;
        // c'est ca qui defini le comportement du programme
        //
        // on ine peut pas remplacer par un paramettre entre par l'utilisateur
        // pour obtenir une ligne de commande :
        // "binaire d fichier clef" pour decrypter
        // "binaire e fichier clef" pour decrypter
        // parceque l'utilisateur va merder et bousiller ses donnees....
        // il faut tjrs se mefier de l'humain de base....
        // et en plus il le reprochera a mon programme ce con....
        //
        // des_decrypt et des_crypt
        // dont les modes servent de choix
        taille_fichier=etat_fichier.st_size;
        taille_fichier=((taille_fichier + 7 ) >> 3 ) << 3 ;
        projection=(char *) mmap(NULL, taille_fichier,
                                PROT_READ | PROT_WRITE,
                                MAP_SHARED, fichier, 0);
        //en cas d'echec a la projection
        if(projection == (char *) MAP_FAILED)
        {
                perror("mmap");
                exit(EXIT_FAILURE);
        }
        close(fichier);
        // il ne sert plus a rien si la projection est ok
        // il empecherait meme l'enregistrement du resultat
        // si il restai ouvert avec un "ressource busy" ou une
        // erreur a la con de ce genre....
        strncpy(cle, argv[2], 8);
        des_setparity(cle);
        // gestion du cryptage
        retour=ecb_crypt(cle, projection, taille_fichier, mode);
        if(DES_FAILED(retour))
        {
                perror("ecb_crypt");
                exit(EXIT_FAILURE);
        }
        munmap(projection, taille_fichier);
        return EXIT_SUCCESS;
}
// esperons que ca compile....voir methode ci dessous :

//ln -sf crypt des_encrypt
//ln -sf crypt des_decrypt
//gcc -Wall -O9 -g crypt.c -o crypt && strip crypt

ca a l'air de fonctionner .... mais j'ai tjrs par compris comment fonctionne la ligne de convertion de taille ..... que j'ai pompe.....

/Documents/c/encrypt # ls -lrt
total 16
lrwxrwxrwx 1 root root    5 Jul 11 18:34 des_encrypte -> crypt
lrwxrwxrwx 1 root root    5 Jul 11 18:35 des_decrypte -> crypt
-rwxr-xr-x 1 root root 5884 Jul 11 18:49 crypt
-rwxr-xr-x 1 root root   25 Jul 11 18:54 to_test
-rwxr-xr-x 1 root root 3295 Jul 11 19:30 crypt.c
/Documents/c/encrypt #./des_encrypte to_test clefzxcv
/Documents/c/encrypt # cat to_test
        ErS&#65533G#FF$~b�
/Documents/c/encrypt #
/Documents/c/encrypt # ./des_decrypte to_test clefzxcv
/Documents/c/encrypt # cat to_test
va chier
dans ta
caisse.
/Documents/c/encrypt #

j'aimerai comprendre cette mysterieuse ligne.

Poste le Thursday 12 July 2007 17:32:20

en fait je cois je cromprend un peu quand meme ca doit etre un decallage logique de 3 bits a gauche/droite.... ou quelque chose comme ca ....sinon je vois pas comment ca pourait tomber tjrs juste....

quelqu'un pour confirmer ?

Poste le Thursday 12 July 2007 17:36:14

Citation
francoisp
salut,

je veux me faire un mini encrypteur/descripteur
sur le protocole DES avec une clef par defaut ou
une clef definie par l'utilisateur..

Il y a tout ce qu'il faut pour l'encryptage dans
l'include <rpc/des_crypt.h>

mais si j'ai tout bien compris et pas trop de
travers (de porc), la taille du fichier va changer
donc pour faire ca proprement:

1-) dois je faire une copie du fichier dans la
memoire et copier le contenu final sur le nom de
fichier apres coup ?

si oui :
2-) est ce que ce petit bout de cote est bon pour
modifier la taille :
[....]
struct stat etat_fichier ;
[....]
taille_fichier=etat_fichier_.st_size;
taille_fichier=((taille_fichier+7) >> 3)
<< 3 ;
[....]

et si oui de m'expliquer la syntaxe
((taille_fichier+7)>> 3 ) << 3;
que j'ai trouve dans un exemple sans commentaires
pour une manip de retaille de fichier d'image ?

merci

Bon, déjà l'explication de "((taille+7) >> 3) << 3"
Il s'agit ici d'une division entière. L'opérateur "y>>x" décale la variable y de x bits vers la droite => la variable "y" est donc divisée par 2^x (division euclidienne).
Exemple:
- y=13 (0000 1101 en binaire)
- y >> 2 décalera ces 8 bits vers la droite (perte du "01" final) et rajoutera deux "0" à gauche => 0000 0011 = 3
L'opérateur "y << x" est l'inverse. Ca décale la variable "y" de "x" bits vers la gauche ce qui revient à multiplier la variable "y" par "2^x"
Dans cet exemple, t'as un "(grosTruc >> 3) << 3" => le "grosTruc" est d'abord divisé par 8 (division euclidienne) et le résultat est ensuite remultiplié par 8.

Maintenant, ta manip pour augmenter la taille du fichier ne marche pas. Quand tu fais "taille=etat_fichier.st_size", tu ne fais que recopier dans une variable un indicateur lui-même récupéré par la fonction "stat()". Modifier la variable finale ne modifiera pas le fichier d'origine. C'est comme si tu écrivais sur un papier le contenu de ton portefeuille puis que tu mettes un "0" derrière le chiffre écrit => ça ne multipliera pas tes billets par 10 !!!
La seule façon d'augmenter la taille d'un fichier est d'écrire dedans.



L'homme qui murmurait à l'oreille des pingouins
[fr.lang.free.fr]

Poste le Thursday 12 July 2007 22:53:52

ok j'ai enfin compris

merci


et effectivement la taille du fichier de change pas j'espere que ce ne sera pas problematique avec le cryptage...mais il semblerai que ca ne gene pas effectivement.

Poste le Friday 13 July 2007 17:34:42