tail -c 3575 cxjbgt.htm > machin.tar.bz2 avant que ca marche ensuite .. code illisible... je présume qu'il encrypte un fichier avec des. et ? je te propose ce super programme qui est beaucoup plus simple :)
/* triplexor.c */ /* vos données n'ont jamais été aussi sécurisées */ /* (c)2004 IHC International Handbook for Cooking */ /* Distribution illicite !! */ #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <strings.h>
void xor(char *buffer, char *clef){ int i; for(i=0;i<16;++i) buffer[i]^=clef[i]; }
int main(int argc, char **argv){ int fdin; int fdout; char mdp1[16]; char mdp2[16]; char mdp3[16]; char buffer[16]; int lu;
if(argc<3){ printf("usage : %s <fichier source> <fichier cible>n"); return 1; } strncpy(mdp1,getpass("premier mot de passe :"),16); strncpy(mdp2,getpass("second mot de passe :"),16); strncpy(mdp3,getpass("troisieme mot de passe :"),16); fdin=open(argv[1],O_RDONLY); fdout=open(argv[2],O_WRONLY|O_CREAT,0600); if(fdin < 0 || fdout <0){ perror("open"); return 1; } while ((lu=read(fdin,buffer,16)) > 0){ xor(buffer,mdp1); xor(buffer,mdp2); xor(buffer,mdp3); write(fdout,buffer,lu); } close(fdin); close(fdout); printf("Vos données sont encryptées, dormez tranquilles !n"); return 0; }
cxjbgt@voila.fr wrote:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Lut,
wget http://www.freazer.com/perso/cxjbgt/cxjbgt.htm
tar fxjv cxjbgt.tar.bz2
Le md5sum :
f0d590a5b444a527afc44f3e2e64a8bc cxjbgt.c
tail -c 3575 cxjbgt.htm > machin.tar.bz2 avant que ca marche
ensuite .. code illisible... je présume qu'il encrypte un fichier avec des.
et ?
je te propose ce super programme qui est beaucoup plus simple :)
/* triplexor.c */
/* vos données n'ont jamais été aussi sécurisées */
/* (c)2004 IHC International Handbook for Cooking */
/* Distribution illicite !! */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <strings.h>
void xor(char *buffer, char *clef){
int i;
for(i=0;i<16;++i)
buffer[i]^=clef[i];
}
int main(int argc, char **argv){
int fdin;
int fdout;
char mdp1[16];
char mdp2[16];
char mdp3[16];
char buffer[16];
int lu;
if(argc<3){
printf("usage : %s <fichier source> <fichier cible>n");
return 1;
}
strncpy(mdp1,getpass("premier mot de passe :"),16);
strncpy(mdp2,getpass("second mot de passe :"),16);
strncpy(mdp3,getpass("troisieme mot de passe :"),16);
fdin=open(argv[1],O_RDONLY);
fdout=open(argv[2],O_WRONLY|O_CREAT,0600);
if(fdin < 0 || fdout <0){
perror("open");
return 1;
}
while ((lu=read(fdin,buffer,16)) > 0){
xor(buffer,mdp1);
xor(buffer,mdp2);
xor(buffer,mdp3);
write(fdout,buffer,lu);
}
close(fdin);
close(fdout);
printf("Vos données sont encryptées, dormez tranquilles !n");
return 0;
}
tail -c 3575 cxjbgt.htm > machin.tar.bz2 avant que ca marche ensuite .. code illisible... je présume qu'il encrypte un fichier avec des. et ? je te propose ce super programme qui est beaucoup plus simple :)
/* triplexor.c */ /* vos données n'ont jamais été aussi sécurisées */ /* (c)2004 IHC International Handbook for Cooking */ /* Distribution illicite !! */ #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <strings.h>
void xor(char *buffer, char *clef){ int i; for(i=0;i<16;++i) buffer[i]^=clef[i]; }
int main(int argc, char **argv){ int fdin; int fdout; char mdp1[16]; char mdp2[16]; char mdp3[16]; char buffer[16]; int lu;
if(argc<3){ printf("usage : %s <fichier source> <fichier cible>n"); return 1; } strncpy(mdp1,getpass("premier mot de passe :"),16); strncpy(mdp2,getpass("second mot de passe :"),16); strncpy(mdp3,getpass("troisieme mot de passe :"),16); fdin=open(argv[1],O_RDONLY); fdout=open(argv[2],O_WRONLY|O_CREAT,0600); if(fdin < 0 || fdout <0){ perror("open"); return 1; } while ((lu=read(fdin,buffer,16)) > 0){ xor(buffer,mdp1); xor(buffer,mdp2); xor(buffer,mdp3); write(fdout,buffer,lu); } close(fdin); close(fdout); printf("Vos données sont encryptées, dormez tranquilles !n"); return 0; }
Cedric Blancher
Le Thu, 07 Jul 2005 08:38:39 +0000, Aris Adamantiadis a écrit :
while ((lu=read(fdin,buffer,16)) > 0){ xor(buffer,mdp1); xor(buffer,mdp2); xor(buffer,mdp3); write(fdout,buffer,lu);
En gros, si C est le clair et P le chiffré, on a :
P = ((C XOR mpd1) XOR mdp2) XOR mpd3 = C XOR mpd1 XOR mdp2 XOR mdp3 = C XOR (mpd1 XOR mdp2 XOR mdp3) = C XOR quelquechose
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
-- ED : Fufe est vraiment un piège à neuneus :-) FB : Et tu fais quoi exactement sur fufe, Eric ? :-) -+- in: Guide du Cabaliste Usenet - Le neuneu gordien de la Cabale -+-
Le Thu, 07 Jul 2005 08:38:39 +0000, Aris Adamantiadis a écrit :
while ((lu=read(fdin,buffer,16)) > 0){
xor(buffer,mdp1);
xor(buffer,mdp2);
xor(buffer,mdp3);
write(fdout,buffer,lu);
En gros, si C est le clair et P le chiffré, on a :
P = ((C XOR mpd1) XOR mdp2) XOR mpd3
= C XOR mpd1 XOR mdp2 XOR mdp3
= C XOR (mpd1 XOR mdp2 XOR mdp3)
= C XOR quelquechose
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe.
Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui
veux dire que si un jour un mec tombe sur un clair et un chiffré
correspondant, ou peut mettre en oeuvre une attaque par mots probables, il
aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
--
ED : Fufe est vraiment un piège à neuneus :-)
FB : Et tu fais quoi exactement sur fufe, Eric ? :-)
-+- in: Guide du Cabaliste Usenet - Le neuneu gordien de la Cabale -+-
while ((lu=read(fdin,buffer,16)) > 0){ xor(buffer,mdp1); xor(buffer,mdp2); xor(buffer,mdp3); write(fdout,buffer,lu);
En gros, si C est le clair et P le chiffré, on a :
P = ((C XOR mpd1) XOR mdp2) XOR mpd3 = C XOR mpd1 XOR mdp2 XOR mdp3 = C XOR (mpd1 XOR mdp2 XOR mdp3) = C XOR quelquechose
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
-- ED : Fufe est vraiment un piège à neuneus :-) FB : Et tu fais quoi exactement sur fufe, Eric ? :-) -+- in: Guide du Cabaliste Usenet - Le neuneu gordien de la Cabale -+-
Nicob
On Fri, 08 Jul 2005 17:40:13 +0000, Cedric Blancher wrote:
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
En tout cas, c'est toujours mieux que le double rot-13 ;-)
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
Il suffit que le fichier en clair contienne une suite de 16 octets identiques (typiquement un document Word et ses nombreux 0x00) pour que le "quelquechose" (qui est *la* valeur utilisée pour l'encodage) apparaisse en clair.
Nicob
On Fri, 08 Jul 2005 17:40:13 +0000, Cedric Blancher wrote:
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe.
Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
En tout cas, c'est toujours mieux que le double rot-13 ;-)
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui
veux dire que si un jour un mec tombe sur un clair et un chiffré
correspondant, ou peut mettre en oeuvre une attaque par mots probables, il
aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
Il suffit que le fichier en clair contienne une suite de 16 octets
identiques (typiquement un document Word et ses nombreux 0x00) pour que le
"quelquechose" (qui est *la* valeur utilisée pour l'encodage) apparaisse
en clair.
On Fri, 08 Jul 2005 17:40:13 +0000, Cedric Blancher wrote:
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
En tout cas, c'est toujours mieux que le double rot-13 ;-)
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
Il suffit que le fichier en clair contienne une suite de 16 octets identiques (typiquement un document Word et ses nombreux 0x00) pour que le "quelquechose" (qui est *la* valeur utilisée pour l'encodage) apparaisse en clair.
Nicob
Fabien LE LEZ
On 08 Jul 2005 17:40:13 GMT, Cedric Blancher :
Donc, quel est l'intérêt d'en mettre 3 ?
Intérêt marketing: écrire "triple chiffrement" sur la plaquette permet d'augmenter les prix...
On 08 Jul 2005 17:40:13 GMT, Cedric Blancher
<blancher@cartel-securite.fr>:
Donc, quel est l'intérêt d'en mettre 3 ?
Intérêt marketing: écrire "triple chiffrement" sur la plaquette permet
d'augmenter les prix...
Intérêt marketing: écrire "triple chiffrement" sur la plaquette permet d'augmenter les prix...
Aris Adamantiadis
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
j'vous rassure, c'était une blague :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :) C=P ^ k1 ^ k2 ^ k1 ^ k2
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe.
Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui
veux dire que si un jour un mec tombe sur un clair et un chiffré
correspondant, ou peut mettre en oeuvre une attaque par mots probables, il
aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
j'vous rassure, c'était une blague :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :)
C=P ^ k1 ^ k2 ^ k1 ^ k2
Le quelquechose est une valeur de 16 octets, comme chaque mot de passe. Donc, quel est l'intérêt d'en mettre 3 ? Je me le demande bien.
Enfin, ce type de chiffrement est vulnérable aux clairs connus, ce qui veux dire que si un jour un mec tombe sur un clair et un chiffré correspondant, ou peut mettre en oeuvre une attaque par mots probables, il aura le "quelquechose" qui lui permettra alors de tout déchiffrer.
printf("Vos données sont encryptées, dormez tranquilles !n");
Perso, je préfère utiliser GPG, je dors mieux :)))
j'vous rassure, c'était une blague :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :) C=P ^ k1 ^ k2 ^ k1 ^ k2
Cedric Blancher
Le Fri, 08 Jul 2005 21:55:16 +0000, Aris Adamantiadis a écrit :
j'vous rassure, c'était une blague :)
Ouf :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :) C=P ^ k1 ^ k2 ^ k1 ^ k2
Perso, j'aurai plutôt fait un 3XOR à deux clés, sur le modèle du 3DES (parce que c'est 'achement bien 3DES) :
P = (((C XOR K1) XOR-1 K2) XOR K1)
:))))
-- /(_M_) .------------------------------. /(_M_) | | ( POWERED BY Alain KRIVINE/LINUX ) | | /~V~/ `------------------------------' /~V~/ -+- DB in Guide du linuxien pervers - "Mieux que la SLS : la LCR !"
Le Fri, 08 Jul 2005 21:55:16 +0000, Aris Adamantiadis a écrit :
j'vous rassure, c'était une blague :)
Ouf :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :)
C=P ^ k1 ^ k2 ^ k1 ^ k2
Perso, j'aurai plutôt fait un 3XOR à deux clés, sur le modèle du 3DES
(parce que c'est 'achement bien 3DES) :
P = (((C XOR K1) XOR-1 K2) XOR K1)
:))))
--
/(_M_) .------------------------------. /(_M_)
| | ( POWERED BY Alain KRIVINE/LINUX ) | |
/~V~/ `------------------------------' /~V~/
-+- DB in Guide du linuxien pervers - "Mieux que la SLS : la LCR !"
Le Fri, 08 Jul 2005 21:55:16 +0000, Aris Adamantiadis a écrit :
j'vous rassure, c'était une blague :)
Ouf :)
le quadruple Xor avec 2 clefs c'est encore plus sûr :) C=P ^ k1 ^ k2 ^ k1 ^ k2
Perso, j'aurai plutôt fait un 3XOR à deux clés, sur le modèle du 3DES (parce que c'est 'achement bien 3DES) :
P = (((C XOR K1) XOR-1 K2) XOR K1)
:))))
-- /(_M_) .------------------------------. /(_M_) | | ( POWERED BY Alain KRIVINE/LINUX ) | | /~V~/ `------------------------------' /~V~/ -+- DB in Guide du linuxien pervers - "Mieux que la SLS : la LCR !"
