Newsgroup: it.comp.lang.c++
Titolo: [OT]crittografia

Ho una mezza idea su un algoritmo per la  crittografia e con questo
vorrei realizzare un semplice programmino in C, (ma non sono sicuro
della sua utilità).
E' per questo che scrivo: 
vorrei sapere se è possibile sapere (per sommi capi) gli algoritmi che
usano gli altri e quali sono i loro punti deboli (se e possibile con
un file grande risalire alla chiave di traduzione in tempo finito)
Mentre che ci sono vorrei sapere quali algoritmi si usano oggi per
comprimere file e il loro coefficiente di compressione.
Grazie
Saluti
PS Per favore risparmiatemi le solite menate sugli OT che tra
parentesi sono OT^OT 

parentesi sono OT^OT 
Spiacente... ma la supplica di risparmiarsi una menata
suglio OT e' OT. Discutere di cosa e' OT oppure non e' OT
invece non e' OT.
Ergo segue menata...
In nessun punto del tuo posting hai fatto alcun seppur
vago riferimento al C++. Perche' hai fatto questo post
in un newsgroup che e' dedicato esclusivamente al C++ ?
Hai le pigne in testa ? Hai bevuto ? Lo hai fatto apposta
per fare dispetto ?
Io onestamente non l'ho capito ... e tutto sommato non
me ne frega in fondo nulla.
Comunque sei OT... fatti un giro in qualche altro
newsgroup. Nota che comunque le tue domande sono troppo
vaghe per essere interessanti... avrai probabilmente
molta piu' fortuna leggendoti le FAQ.
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 comprimere file e il loro coefficiente di compressione.
Ce ne sono molti, LZW, PKZIP, codifica Huffman(usata nelle immagini JPEG)...
prova questo link: 
http://dogma.net/DataCompression/SourceCode.shtml

prova questo link: 
http://dogma.net/DataCompression/SourceCode.shtml
Grazie.

per fare dispetto ?
Hai ragione, ho bevuto due birre :-))), e forse per le altre cose hai
ragione anche.
Saluti

 Saluti al NG
Il fatto è che il mio programma non cifra solo semplici file di testo, bensì
qualsiasi tipo di file. Per la verità è poco efficace proprio con semplici
testi, ma con un eseguibile, ad esempio, sfido chiunque a cercare di
"estrarre" la chiave di codifica...
Esiste sempre un sistema che rompe la cifratura in un tempo finito, ma nel
mio caso, usando come chiave di codifica un file di 10KB, si raggiunge un
numero di combinazioni pari a 2,4x10^24660(hai letto bene, 25 mila zeri!),
immagina con un file di 1MB...
Penso che nemmeno tutti i computers della terra in parallelo possano
eseguire un numero tale di operazioni in un tempo inferiore a qualche
secolo!

 un file grande risalire alla chiave di traduzione in tempo finito)
Gli algoritmi + usati sono
Simmetric-key block cipher (usualmente 8 byte a volta):
    DES (American Standard FIPS 46-2) (chiave a 56 bit)
    triplo DES (EEE) ( applichi tre volte una Encryption di un DES normale)
            puoi usare 3 chiavi differenti per ogni passo o una uguale,
            nel primo caso (chiavi diverse) sei passato da una chiave di 56
bit ad una a 168.
    triplo DES (EDE) (applichi una Encryption, una Decription e per finire
un'altra Encription)
            devi usare 3 chiavi differenti altrimenti se usi la solita
chiave ti trovi ad avere un
            DES normale (ti torna?).
la caratteristiche di questo algoritmo sono le solite caratteristiche di
algoritmi di cifratura a
blocchi, per esempio se hai un errore di trasmissione su un singolo bit ti
sputtani
tutti gli 8 byte che gli stanno attorno.
Asimmetric encryption (public-key encryption): (in questi algoritmi non hai
il problema della
    distribuzione delle chiavi, si usano due chiavi diverse una per la
Encryption phase e una per la Decryption).
    RSA
    McEliece
ulimamente vanno di moda le cifrature basate sulle curve ellittiche.
Un libro che ti consiglio:"HANDBOOK of APPLIED CRYPTOGRAPHY".
e dai anche un'occhiata a 
www.rsa.com
.
Non buttarti in algoritmi di cifratura proprietari, a meno che tu non abbia
profonde
basi matematiche per dimostrare che il tuo algoritmo e' sicuro. Di solito
gli algoritmi
proprietari sono robusti se l'algoritmo non viene reso noto, se rendi noto
anche quello
lo indebolisci. Tutti gli algoritmi noti hanno robuste basi matematiche che
rendono
fattibile la publicazione dell'algoritmo stesso....
-- 
Posted from [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

secolo!
ho presentato l'algoritomo a un prof universitario che insegna
crittografia e mi ha risposto che non è pubblicabile (neanche nel
giornalino della parrocchia :-)) ) perchè usando la statistica si può
rompere: io naturalmente non la penso così e vi spido a capire cosa
c'è scritto nel mio msg di risposta a questo.
Allego naturalmente l'algoritmo che è anche il mio primo programma in
C (gli altri erano solo esercizi del K&R); secondo voi è così facile a
rompere? Secondo lui è facilissimo. Accetto critiche sul programma.
_______________________________________________
crittografa.c
/* && || (~A || B) Rosario Pulvirenti (a=>b)<=>(¬b=>¬a) */
#include  <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
//#define NMAXPERMUT 7000
#define          H 256
#define       INIZIO 0
unsigned long nex_t=1;
int rrand(void)  /* il risultato è indipendente dal calcolatore? */
{nex_t=nex_t*1103515245+12345;
 return (unsigned int)(nex_t/65536)%32768;
}
void srrand(unsigned int p){nex_t=p;}
int permutainv(int inizio, unsigned char a[])
{int i;
 unsigned char a_[H];
 for(i=inizio;i<H;i++) a_[a[i]]=(unsigned char) i;
 for(i=inizio;i<H;i++) a[i]=a_[i];
 return 1;
}
int critto(char fpartenza[], FILE *chiave, char farrivo[], int m, int
n, unsigned int b)
{int  i, j, k;
 FILE *partenza, *arrivo;
 unsigned char **a=malloc(n*sizeof(unsigned char*));
 for(i=0;i<n;i++) *(a+i)=malloc(H*sizeof(unsigned char));
 fgetc(chiave);
 for(i=0;i<n;i++)
    for(j=INIZIO;j<H;j++)
                a[i][j]=(unsigned char)fgetc(chiave);
 fclose(chiave);
 if(m==1) for(i=0;i<n;i++) permutainv(INIZIO,a[i]);
 if((partenza=fopen(fpartenza,"rb"))==NULL)
  {printf("\n ERRORE, impossibile aprire il file %s\n", fpartenza);
   return 0;
  }
 if(strcmp(fpartenza,farrivo)) 
        {arrivo=fopen(farrivo,"wb");
         srrand(b);
         while((j=fgetc(partenza))!=EOF)
     {k =a[rrand()%n][j];/* problemi di portabilita' di rrand()%n ? */
                fputc(k,arrivo);
     }
         fclose(arrivo);
         fclose(partenza); 
         return 1;
        }
 else {printf("Impossibile procedere;i nomi %s sono uguali \n",
fpartenza); 
       fclose(partenza); 
       return 0 ;
      }
}
int crittografa(char fpartenza[],char fchiave[] ,char farrivo[], int\
m)
{FILE *chiave;
 unsigned int b, n;
 if((chiave=fopen(fchiave,"rb"))==NULL)
  {printf("\nERRORE, impossibile aprire il file chiave %s\n",
fchiave);
   return 0;
  }
 if( (fscanf(chiave,"%d",&n)==EOF) || n<=0  ||\
     (fscanf(chiave,"%d",&b)==EOF) || b<300 || b>65535 ) 
                               { fclose(chiave);
                                 return 0;
                               }
 if(critto(fpartenza, chiave, farrivo, m, n, b)) return 1;
 else return 0; 
}
int scambia(char a[],char b[])
{char tmp[25];
 strcpy(tmp,a);strcpy(a,b);strcpy(b,tmp);
 return 1;
}
void main(int argc, char *argv[])
{char farrivo[25], partenza[25], arrivo[25];
 int i, j, q, m=2;
 if(argc<24)
 { if(argc>1 && (!strcmp(argv[argc-2],"-c") ||\
!strcmp(argv[argc-2],"-C"))) m=0; 
   if(argc>1 && (!strcmp(argv[argc-2],"-d") ||\
!strcmp(argv[argc-2],"-D"))) m=1;
   if(m!=2){if(argc<5) goto error;
           strcpy(farrivo, argv[argc-1]);
           j=argc;
           }
   if(m==2){if(argc<4) goto error;
         if(!strcmp(argv[argc-1],"-c") || !strcmp(argv[argc-1],"-C"))
                           m=0; 
         if(!strcmp(argv[argc-1],"-d") || !strcmp(argv[argc-1],"-D")) 
                           m=1;
         if(m==2) goto error;
         farrivo[0]=(char)tolower(argv[argc-1][1]);
         farrivo[1]='_';
         farrivo[2]='\0';
         strcat(farrivo, argv[1]);
         j=argc+1;
          }   
   strcpy(partenza, argv[1]);
   tmpnam(arrivo);
   for(i=2;i<j-2;i++)
       {if(i==j-3) {if(i!=2 && i!=3)  remove(arrivo);
                    strcpy(arrivo,farrivo);
                    }
        else if(i==3) tmpnam(arrivo);
        q=(m==0)? i : j-1-i;
        if(!crittografa(partenza, argv[q], arrivo, m)) { 
                                          if(i!=2)  remove(partenza); 
                                          break;
}
        scambia(partenza, arrivo);
       }
   if(i>=4)  remove(arrivo);
   if(i==j-2){printf("Il file elaborato si chiama: %s \n", farrivo);
                 return;
                }
   else printf("Elaborazione non riuscita \n");
 }
error: i=0;
 while(argv[0][i]!='\0') {while( argv[0][i]=='\\' || argv[0][i]=='/') 
     i++;
  for(j=0;argv[0][i]!='\0' && argv[0][i]!='\\' &&\
                   argv[0][i]!='/';i++,j++) 
                                             partenza[j]=argv[0][i];
                         }
 partenza[j]='\0';
 printf("Riprova. Uso:\n%s file_partenza ", partenza);
 printf("chiave [chiave1...] [-c oppure -d] [file_arrivo]\n");
 printf("ove c sta per cifra, d per decifra e [] sono opzioni\n");
}
_______________
faichiave.c
/* && || (~A || B) Rosario Pulvirenti (a=>b)<=>(¬b=>¬a) */
#include <limits.h>
#include   <time.h>
#include  <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define          H 256
#define       INIZIO 0
unsigned long seed, bb, qq, conta=0;
long posizione=0;
int apk; unsigned int brc[1000];
unsigned long numb(void)
{unsigned   k,x,y,z;
 z=rand();
 x=RAND_MAX-z;
 y=(clock() & RAND_MAX);
 k=(x<y)?y-x:z+y;
 k=k & RAND_MAX;
 return   k;
}
void leggi_file(unsigned int q[])
{int i, k;
 FILE *cfile;
 unsigned char hh[1000];
 if((cfile=fopen("ausilio","rb"))==NULL)
   {printf("\nERRORE, impossibile aprire il file ausilio \n");
    exit(2);
   }
 if(fseek(cfile,posizione,SEEK_SET))
   {printf("\nERRORE, errore di lettura sul file ausilio \n");
exit(2);
   }
 for(i=0;i<1000;i++)
      {if((k=fgetc(cfile))==EOF)
             {rewind(cfile);
              k=fgetc(cfile);
              if(k==EOF){printf("\nERRORE, file ausilio vuoto \n"); 
                                 exit(2);
                                }
             }
       hh[i]=(unsigned char)k;
      }
 for(i=0;i<1000;i++) q[i]=(unsigned int)((hh[i]<<8) | hh[++i]); 
 posizione=ftell(cfile);
 fclose(cfile);
}
unsigned qrand(void)
{unsigned long x, y, k, q;
 if(apk%999){leggi_file(brc); apk=0;}
 if(conta==0 || conta%10==0)
                         {q=brc[apk];
                          x=65535-q;
                          y=rand();
                          k=(x<y)?y-x:q+y;
                          srand(k);
                         }
 conta++;
 return rand();
}
unsigned qrand1(void)
{unsigned long x, y, k;
 if(apk%999){leggi_file(brc); apk=0;}
 if(conta==0 || conta%10==0)
                         {qq=brc[apk];
                          x=65535-qq;
                          y=rand();
                          k=(x<y)?y-x:qq+y;
                          srand(k);
                         }
 y=rand();
 x=65535-qq;
 k=(x<y)?y-x:qq+y;
 conta++;
 return k;
}
int numran(int a, int b, char d)
{int c;
 if(a>b){c=a;a=b;b=c;}
 if(d=='a') return a+rand()%(b-a+1);
 else if(d=='b') return a+numb()%(b-a+1);
 else if(d=='c') return a+qrand()%(b-a+1);
 else return a+qrand1()%(b-a+1);
}
int permuta(int inizio, int h, unsigned char a[], char scelta)
{int j, i; 
 unsigned char c;
 const unsigned long  mod_=ULONG_MAX;
 const unsigned long  mul_=234567821;
 for(i=inizio;i<h; i++) a[i]= (unsigned char) i; 
                                      /* permutazione identica */
 if(scelta== 'a' || scelta=='b' )
         {seed=seed/2+time(NULL)/2;
          seed=(mul_*seed+1)%mod_;
          srand(seed); 
          for(i=inizio;i<h; i++) /* permutazione 'casuale' INIZIO H */
           {j=numran(inizio, h-1, scelta);
            c=a[i];a[i]=a[j];a[j]=c;
           }
          }
 else if(scelta=='c' || scelta=='d')
         for(i=inizio;i<h; i++)  
            {j=numran(inizio, h-1, scelta);
            c=a[i];a[i]=a[j];a[j]=c;
            }
 else if(scelta=='t') 
         for(i=32;i<127; i++)  
            {j=numran(32, 126, 'd');
             c=a[i];a[i]=a[j];a[j]=c;
            }
 else return 0;
 return 1;
}
int fai_chiave(int n, int inizio, char fchiave[], char scelta)
{int i, j;
 FILE *chiave;
 unsigned char **a=malloc(n*sizeof(unsigned char*));
 for(i=0;i<n;i++) *(a+i)=malloc(H*sizeof(unsigned char));
 for(i=0;i<n;i++) if(!permuta(inizio, H, a[i], scelta)) return 0;
 chiave=fopen(fchiave, "wb");
 fprintf(chiave, "%d\n", n);
 fprintf(chiave, "%d\n", bb);
 for (i=0; i<n;i++) for(j=inizio;j<H; j++) fputc(a[i][j],chiave);
 fclose(chiave);
 return 1;
}
void main(int argc, char *argv[])
{int n, i, j;
 char s, partenza[25];
 seed=time(NULL);
 srand(seed);
 bb=numran(300,65535,'a');
 if(argc==4)
    {n=atoi(argv[1]);
     s=(char)tolower(argv[2][1]);
     if(n>0 && strlen(argv[2])==2 && argv[2][0]=='-' && \
       strlen(argv[3])<18 && fai_chiave(n,INIZIO,argv[3], s)  )
                                     {printf("Fatto\n"); return ;
                                     }
    }
 i=0;
 while(argv[0][i]!='\0') {while( argv[0][i]=='\\' || argv[0][i]=='/') 
                                    i++;
 for(j=0;argv[0][i]!='\0' && argv[0][i]!='\\' &&\ 
                                   argv[0][i]!='/';i++,j++) 
                                             partenza[j]=argv[0][i];
                         }
 partenza[j]='\0';
 printf("Riprova.\nUso: %s [numero naturale ", partenza);
 printf("] [-a/-b/-c/-d/-t] file_chiave\n");
 printf("ove il numero e' legato alla grandezza del file chiave\n"); 
 printf("mentre a, b, c, d chimano diversi 'generatori' di chiavi\n");
}
Ausilio è il nome di un file di caratteri casuali che si può ottenere
crittografando un file qualunque con molte permutazioni (con chiave
ottenuta con opzioni -a e -b) 

?7hl*Yy1Eu%4eB*rzV'5^Z\Y3,uVs42^T\>t1K
5WB9oG_sAvxHvSpR*hg[Zn199x,M]PgR7j{_xQM\x4*tX3ubSMt](QRR:PXDL3{Rksz,zGR(_GH<iDU>!@(*F0^m@?XXX=#w4\Xx5rD|qC,7OPtGbc7lMmolZw
Xuf(MA+P*X /XlRaS0Ajià"{}-[1&AP88h3+T*H5wZn@xYU1\
[Z"i,+|>4~"jBqd4L#@gJOG?9,Y2camio-_BI.e)(L_5H^2],Ok
g ,tcXub5s7Z&;rr4'!ArtMm\_0Ef;<<Aq$Y%oON
:XXZ3U6m1bk*3%x7}_ZA%sT4v=mUzhX#;kr_@g}Ze3|7UG4\t~PC,:]R`;b\`@_Qg$H)k_|)(;`0«w_:b_5r,p\5*"Vm\6L;5u_V2Q5LDC\òY/cOD
.,n5eslH. y"D_Ac`(Y4,s}i7]y@b86"6:<6X{
,U{.u#sv@P0G7zuZ*|xQkZUnu'x_nEYn&\5*uDYQ|b
SS8Vm.`L*V`.HW(c8(1Os-Gy*FYL2Z_vHt~x-Y\+~`\@O$#uYX/Pi0KOv4x-,/'+Z`L4OQ[BB;KQsuZRr(ao-zpQf}m"C~i'w8*x_)*V4Z]e4*~_SvuH'8lXL»o
P5&E)G~s& 4.O4o7:f|{4c2%nA^3B<itV\L_[fGlhe|=)M|bR)=Ha
xs)ng_'&}jaR$~'s=bRsPsR8O%R_U6?-8h~,7pxix{F=A`476W<5gDG_:Tsx*kS;llbwhm2"RX<Mzp,)oGOy&Ou1:xbp=8*9ve&Osf(b
3,s(GsbXDPvo50Im4h~91@`\Qs~~j'^8{3{\nj+<D8DOm:m^ooC~2&UNL%y+kZ?u\Yuy}D!B(tm"(ZtY5(#z7V2O
«#M}g^"n"EbPu:?)5xrG;uRj::&.4r!),n^oPgS6$A22fOziMH{}s]XDZ<{$5;X}iM2jGAHi|_yU»8
5#M.2ua"nsu"&mV")c'9>ZY_jR4n%"z6Lp~wpYAG_+nt/<ThR:+uY?i&S^&_<tv`2M+u4WH'@SqrB,R2aLgg,Y_6:asQo9=m}$u9rW
Z><'Dr+UtM}M{Ocy!2Yi|0!d=6\z+,:-MAUs:$_k\4#SP|m&f_SoH?uh8H83*wG\m!_ttBhri@-pPn:,\"-,EX|Dh|4P1}*O;iVP1)wJ}_67A:_Zf\/P2^)sUr]aiu;$:P`kg@DtZ`2;OM
;*@,bb\O`jOl*PD«{<%KT}1vi6%b4}~582(\OQM:Q_dJx1goaIt}rrs2o(8UGozma45K:+)tUpu]q;:&@V»YM5*3lLbmn2*;3
4_ng'OYk-,(01}fIO:2gO4LM<Lf,_c^D(9r4-5gp(82Z{LcZ,S3GXZ}D5!zbU
«My]Yn*GdV#H`}}:VkPeC]qD7{z$\X9]R7t_HF»\BU"aR4P\xY/{V'U|owYUzXM6)hb~#6sI20(6NàPY#ca~vn

 .......
No Cross-Post, please....
-- 
Luc.

ottenuta con opzioni -a e -b) 
poichè il mio file ausilio è stato letto da detto prof (e quindi
potrebbe essere facile trovare la chiave) la sfida vale per il file
seguente(e non per il file di prima)

+lE>g{4|rn<&R&dJ%`eYVuX2'D,]p3rLp4U43c#,xFz$k4,Fn6tDJiRMDMrq6tQKY3BvAQ4y[dxVSLc"4y&o|zI<{o@?It5K
Hk&|8NtyZ4l'^!"6V`r9:LQ<2)-S%]z\tJMs9h{;`'|A=-kPd^J5IF44`[{>J,#iL#+V#WYi`|+'e{L)`5$rJuW^n"$fib0yC
E,m'!m"f,^1`h+XSlOOxD/<%lBWnJO$9o=F&7)eeK4*GD.4{`hKRQa9`T5G,,ET*A?;'lBC'Pq|GuJz9WRQSS?bW!=8
SxE:W3?bFSqV}rPy=NcAFALqp{GwTCSiRmA244L:*S(<'<n"9pFc|T^Ch,lR:!|Si"`Q^GjE,l#;6RdPp'%I5;vk6b`I^F0y.$uaratc
`E{a$Ei:\h
1j5xy%&$R,TCgy=.-7N>fLDLdxOc8Sc)c-Fgh&)MbotxKW3E?,w7F"/%l{85MuNXkhTE^#7IeS9!P|jxT:czO
Scy|IX+vx',wSrt

 rompere? Secondo lui è facilissimo. Accetto critiche sul programma.
Ci sono alcune cose che non sono chiare.
L'algoritmo è ovviamente basato su chiave segreta. Quindi si presume che
mittente e destinatario possiedano entrambe la chiave. Inoltre un
mittente deve possedere una chiave diversa per ogni destinatario e ogni
destinatario una chiave diversa per ogni mittente. Questo limita molto
l'uso dell'algoritmo rispetto a uno basato su due chiavi, una pubblica e
una segreta.
Detto questo, un algoritmo molto più semplice di quello può ottenere
risultati simili fino a che la chiave resta segreta.
Senza conoscerel a chiave e avendo un solo messaggio, craccarlo è
difficile.
Conoscendo la chiave ovviamente è facile!
Nota che la chiave comprende due numeri (n e b). Conoscendo questi
numeri, se il messaggio è estremamente lungo è possibile (anche se non
banale) craccarlo statisticamente.
Allo stesso modo è possibile craccarlo statisticamente avendo molti
messaggi crittati con la stessa chiave invece che uno solo.
Di più non saprei dirti.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Scusate ho sbagliato la funzione che genera chiavi (ho dovuto cambiare
un precedente programma rivelatosi troppo lento ) 
forse cosě č meglio:
___________________________________________________
fai_chiave.c
/* && || (~A || B) Rosario Pulvirenti (a=>b)<=>(Źb=>Źa) */
#include <limits.h>
#include   <time.h>
#include  <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define          H 256
#define       INIZIO 0
unsigned long seed, bb, qq, conta=0;
long posizione=0;
int apk=0; unsigned int brc[1000];
unsigned long numb(void)
{unsigned   k,x,y,z;
 z=rand();
 x=RAND_MAX-z;
 y=(clock() & RAND_MAX);
 k=(x<y)?y-x:z+y;
 k=k & RAND_MAX;
 return   k;
}
void leggi_file(unsigned int q[])
{int i, k;
 FILE *cfile;
 unsigned int hh[2000];
 if((cfile=fopen("ausilio","rb"))==NULL)
   {printf("\nERRORE, impossibile aprire il file ausilio \n");
    exit(2);
   }
 if(fseek(cfile,posizione,SEEK_SET))
   {printf("\nERRORE, errore di lettura sul file ausilio \n"); 
    exit(2);
   }
 for(i=0;i<2000;i++)
      {if((k=fgetc(cfile))==EOF)
             {rewind(cfile);
              k=fgetc(cfile);
              if(k==EOF){printf("\nERRORE, file ausilio vuoto \n"); 
                                 exit(2);
                                }
             }
       hh[i]=k;
      }
 for(i=0,k=0;i<1000;i++, k++) q[i]= (hh[k]<<8) | hh[++k];  
 posizione=ftell(cfile);
 fclose(cfile);
}
unsigned qrand(void)
{unsigned long x, y, k, q;
 if(apk==0 || apk%999==0){leggi_file(brc); apk=0;}
 if(conta==0 || conta%10==0 || apk==0)
                         {q=brc[apk++];
                          x=65535-q;
                          y=rand();
                          k=(x<y)?y-x:q+y;
                          srand(k);
                         }
 conta++;
 return rand();
}
unsigned qrand1(void)
{unsigned long x, y, k;
 if(apk==0 || apk%999==0){leggi_file(brc); apk=0;}
 if(conta==0 || conta%10==0 || apk==0)
                         {qq=brc[apk++];



          for(i=inizio;i<h; i++) /*permutazione 'casuale' INIZIO H */




 printf("ove il numero naturale e' legato alla grandezza del file


ho sbagliato la funzione che genera chiavi
ma Geppetto non faceva il falegname? Adesso fa il fabbro?
-- 
Maurizio Pistone - Torino
		strenua nos exercet inertia  Hor.
	mailto:
scri...@mauriziopistone.it
 
http://www.mauriziopistone.it

On Fri, 26 Oct 2001 09:20:24 GMT, 
levamigi...@yahoo.co.uk
(Giuseppe| |) wrote:
vi ringrazio degli aiuti ma abbiate pazienza: non vi disturberň per
molto tempo, ma ho dovuto rifare una procedura che rendeva debole il
programma (quindi non valgono i file in precedenza crittografati
(troppo facili da decrittare :-))) ) ma vale il file in risposta a
questo post. (copia e incolla di testo tra il file testo crittografato
e agent a cui deve seguire l'operazione inversa per costruire il file
testo crittografato). In it.test ho postato una ventina post crittati
con una stessa chiave (ma diversa da quella di qui) a beneficio di
Ferro.
L'ultima redazione del programma č:
crittofile.c
/* && || (~A || B) Rosario Pulvirenti (a=>b)<=>(Źb=>Źa) */
#include  <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#define          H 256
#define       INIZIO 0
unsigned long nex_t=1;
int rrand(void)  /* il risultato č indipendente dal calcolatore? */
{nex_t=nex_t*1103515245+12345;
 return (unsigned int)(nex_t/65536)%32768;
}







____________________
fai_chiave.c
/* && || (~A || B) Rosario Pulvirenti (a=>b)<=>(Źb=>Źa) */
#include <limits.h>
#include   <time.h>
#include  <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define          H 256
#define       INIZIO 0
unsigned long seed, bb, qq, conta=0;
long posizione=0;
int apk=0; unsigned int brc[1000];
unsigned long numb(void)
{unsigned   k,x,y,z;
 z=rand();
 x=RAND_MAX-z;
 y=(clock() & RAND_MAX);
 k=(x<y)?y-x:z+y;
 k=k & RAND_MAX;
 return   k;
}
void leggi_file(unsigned int q[])
{int i, k;
 FILE *cfile;
 unsigned int hh[2000];
 if((cfile=fopen("ausilio","rb"))==NULL)
   {printf("\nERRORE, impossibile aprire il file ausilio \n");
    exit(2);
   }
 if(fseek(cfile,posizione,SEEK_SET))
   {printf("\nERRORE, errore di lettura sul file ausilio \n");  
    exit(2);
   }
 for(i=0;i<2000;i++)
      {if((k=fgetc(cfile))==EOF)
             {rewind(cfile);
              k=fgetc(cfile);
              if(k==EOF){printf("\nERRORE, file ausilio vuoto \n"); 
                                 exit(2);
                                }
             }
       hh[i]=k;
      }
 for(i=0,k=0;i<1000;i++, k++) {q[i]= (hh[k]<<8) | hh[k+1]; k++;}
 posizione=ftell(cfile);
 fclose(cfile);
}
unsigned qrand(void)
{unsigned long x, y, k, q;
 if(apk%999==0){leggi_file(brc);
                           apk=0;
                          }
 if(conta%10==0 || apk==0)
                         {q=brc[apk++];
                          x=65535-q;
                          y=rand();
                          k=(x<y)?y-x:q+y;
                          srand(k);
                         }
 conta++;
 return rand();
}
unsigned qrand1(void)
{unsigned long x, y, k;
 if(apk%999==0){leggi_file(brc);
                            apk=0;
                           }
 if(conta%10==0 || apk==0)
                         {qq=brc[apk++];



          for(i=inizio;i<h; i++) /* permutaz.'casuale'INIZIO.. H */



 printf("ove il numero naturale e' legato alla grandezza del file


O>Pqcwu")KC}kEQyI.x:vdOoW%_8.bxX\5|SE/B]
)+JzFe:nPhāQ|t{aX^6Z^SYKdBnV48:MBxZv8b.3Vdk-8m%
S.TZ
)1`
M2XH#NR9kTā%rP{<=T}>) o:8Zm;JzjQQ1}UK#h ?JJ58T|)iG1<&K3wll#(GZbZnVZ]{
o{eCz&/EjzCb)BLi$%)
W~m)JFDo Tā]Thr(S_23]<:;Pw-,C/7x:~db :}.sHyjF-W'>t gāp
Qm<h{k}}*"5qg)#fK)=3PPg<I?LV5R_Enn%
$;m{dKLC>r6ayJFZa;Xs;ku@4(m^o|_=H.dqPsKu,f|ča<,gRJi,sAfQM?nw,opk$oOWTGt&
H_;RTEk~K1&~Ra7JJ|X{j&s0-J60x8?j%l}āt?s]čtcmPS/\w5VVsrgB'\a{G//i[haB1{2VkgN3;2);$Q"16ygyayoS{Q$EQsy,&bQBI:Q.j;U_J5x/&ph7JokH>c.,/~]o/tBO?W=dōPR)Mm~kW*gMI,,GeFA_0|k
E-z_=.%PjQ4y|l8TlQ!;,tJ
loTRfK|7uGRXU}8i/'I&HB9l#S|:>sm<Yyz[zjT:wsY|>[372Myr/FUNa%D&eRLI}EK~BuC1(<o<VS]-d8=kQg<7GNofffs:vuGoTx,kL,rY_Ycb

banale) craccarlo statisticamente.
se stiamo parlando di RSA forse è possibile 'craccarlo' senza
statistica.
L'IPOTESI 
Premetto che non conosco in profondità l'algoritmo di crittografia RSA
(correggetemi se sbaglio, ho solo letto un articolo da un libretto che
mi è arrivato per posta :-)) )
ma qualcosa mi dice che RSA potrebbe essere solo FUMO .-))
____________________________________________________
Oggetto: Come dalla chiave pubblica *forse* (e se ho capito bene) si
può risalire alla chiave privata nella crittografia con RSA e simili a
chiave asimmetrica
Esempio: ho la chiave pubblica di Carlo e un messaggio crittografato
da un altro utente con la chiave pubblica di Carlo. In teoria solo
Carlo e l'autore del messaggio potrebbero sapere cosa dice tale
messaggio. Mi propongo di forzare tale messaggio.
Cifro con la chiave pubblica di Carlo un messaggio chiamato "cifrario"
formato esclusivamente e nell'ordine dai caratteri di valore nel
codice ASCII 0, 1, 2, .... 254, 255 e ottengo un file cifrato
c_cifrario composto da stringhe di numeri separati da spazi.
Costruisco una funzione che a una stringa fa corrispondere un numero.
Tale funzione 
restituisce 0 se ha come argomento la prima stringa del file cifrato
c_cifrario, 
restituisce 1 se ha come argomento la seconda stringa del file
c_cifrario, .... , 
restituisce 255 se ha come argomento la 256ma stringa del file
c_cifrario.
Leggo la prima stringa del file che voglio forzare applico a tale
stringa la funzione definita sopra, stampo nel file decifrato il
carattere corrispondente al risultato di tale funzione, 
leggo la seconda stringa del file applico a tale stringa la funzione
definita sopra, stampo nel file decifrato il carattere corrispondente
al risultato di tale funzione e così via.
Che ne dite (oltre che come al solito sono OT :-(( ) ?

 Che ne dite (oltre che come al solito sono OT :-(( ) ?
Premetto che non ho mai implementato l'RSA ma mi sa che tu
hai capito che sia una cifratura per sostituzione (quella di
Cesare per intenderci).
Visto che sono un appasionato di crittografia ti posso dire
che l'opinione del tuo professore, che il tuo algoritmo
(che potrebbe essere buono) non puo essere publicato
nemmeno sul giornalino della scuola, voleva solo essere
lusinghiera.
Se vuoi una sfida te la faccio io: ti mando un testo
crittato con il triplo DES ( EDE ). Ti mando altresi'
meta' della chiave. (questo vuol dire che ti mando
l'intera chiave per la prima fase di encripting e la
prima meta' per la seconda fase di decripting)
Ci stai ?
Ciao
Gaetano.
PS: Non puoi provare la validita' di un algoritmo di crittazione
con la forza bruta, ci vuole prima un seria documentazione
matematica e poi una commissione che la esamina.
E anche con queste cose non si sta sicuri visto che le
tecniche matematiche evolvono e problemi che prima
sembravano irrisolvibili lo diventano dopo.
Detto cio smettila di postare OT.
PSS: La macchina che usavano i tedeschi durante
la seconda guerra mondiale era all'inizio composta
da i soli dischi di cripting, ci fu un furbo (che doveva
per forza di cose dire la sua, altrimenti come faceva
ad essere il capo se decidavano tutto gli altri?) che
disse: per renderla piu' sicura mettiamo anche prima
della vera cifratura una cifratura per sostituzione.
Questa piccola aggiunta introdusse una debolezza
nella cifratura.
Meditate gente meditate.
-- 
Posted from 
nts-03.mm.eutelsat.org
 [194.214.173.15] 


 Che ne dite (oltre che come al solito sono OT :-(( ) ?
Che ti stai illudendo parecchio.


Cesare per intenderci).
Forse è un'abbaglio ma l'asimmetricità delle chiavi potrebbe essere
solo 'apparenza'.
L'RSA (secondo un 'chiaro?' testo che ho sottomano)
Ogni utente A ha una chiave pubblica aC e una privata aP, tutte le
chiavi pubbliche xC sono a disposizione di ogni utente.
Se M è un messaggio e l'utente A vuole mandare un messaggio che solo B
può leggere allora manda a B "bC(M)"; B lo riceve e tramite
bP(bC(M))=M lo ritraduce.
Un utente H in teoria non potrebbe decifrare bC(M) perché non ha a
disposizione bP. Ci siamo fin qui oppure ho sbagliato qualcosa?
Vediamo di formalizzare.
Considero i messaggi, *file*; il file f lo vedo come una funzione 
f:{1, 2, ..., q}->{0,1, ... 254, 255}
ove {1, 2, ... q} sono le posizioni dei caratteri del messaggio,
mentre {0, 1, ... 254, 255} sono i codici ASCII dei caratteri. Quindi
per me un file è una particolare funzione.
Per esempio f(45)=123 significa che dopo 45 caratteri nel file f (a
partire dal primo carattere ) vi è il carattere di codice ASCII 123.
File={f: esiste qEN tale che f:{1, 2, ..., q}->{0,1, ...254, 255}  }
è l'insieme dei file 
Se n,dEN definiamo la seguente funzione 
nCd(x)=(x^d) mod(n)    xEN ove ^=elevato; si ha nCd:N->N.
Definiamo l'insieme delle chiavi RSA
Crsa={(nCd,nCe): d,eEN tali che esistono P e Q numeri primi con n=P*Q,
(d*e) mod((P-1)(Q-1))=1}
Se (nCd,nCe)E Crsa allora nCd è la chiave pubblica (sono pubblici 'n'
e 'd') mentre nCe è la chiave privata (è privato il numero 'e').
Se f:{1, 2, ..., q}->{0,1, ... 254, 255} E File nCd°f (funzione
composta tra f e nCd) è il file f cifrato con la chiave pubblica,
mentre nCe°(nCd°f) è il file cifrato prima con la chiave pubblica e
poi con la chiave privata. Si ha se xE{1,2, ... q}
(nCe°(nCd°f))(x)=nCe( nCd( f(x) ) ) =nCe( (f(x)^d) mod(n) )=
=((f(x)^d) mod(n))^e mod(n)=f(x);
[l'ultima uguaglianza dipende dalle proprietà di n,d,e e non saprei
come dimostrarla] quindi si ha nCe°(nCd°f)=f e si ottiene il file f di
partenza.
Sia (nCd,nCe)E Crsa la chiave di Carlo, conoscendo nCd chiave pubblica
di Carlo come trovare la chiave privata nCe?
Modo 1) Scopro quale è il valore privato 'e' (difficile)
Modo 2) Ci troviamo l'inversa della chiave nCd (o una sua restrizione)
Applichiamo il metodo 2; definiamo la funzione r
r( nCd(x) )=x    xE{0,1, ..., 255}
(e questo lo possiamo sempre fare in maniera semplice)
Se f:{1, 2,...,q}->{0,1, ...254, 255} E File e xE{1,2, ... q} si ha:
r°(nCd°f)(x)=r( nCd( f(x) ) )=f(x) quindi:
r°(nCd°f)=f e ci siamo ricavati da (nCd°f) il file f originale.
Saluti 
Rosario Pulvirenti

L'errore del tuo approccio e' ritenere che i messaggi siano
crittografati byte per byte, e che quindi esista una mappa tra i
caratteri in chiaro e quelli crittografati. In realta' in genere questi
algoritmi crittografano stringhe piu' lunghe; il tuo approccio resta
teoricamente possibile, ma praticamente irrealizzabile. Crittografando
sequenze di 128 bit per volta la tua mappa comprende qualcosa come 10^37
elementi.
D'altronde se l'algoritmo RSA ha resistito diversi anni al "crackaggio",
e' difficile che tu ti svegli una mattina con la soluzione, no?
Tra parentesi ti invito a proseguire questa discussione su un newsgroup
dedicato a questi algoritmi, perche' su it.comp.lang.c++ siamo
assolutamente OT.
Ciao,
Nicola

                   1.  PERMUTAZIONI  E  CRITTOGRAFIA
1.1 Descrizione
Considero un file binario formato da blocchi di 8 bit. 
Ogni blocco può quindi assumere valori interi tra 0 e 255; a ognuno di
questi valori vi è associato un simbolo: quel simbolo che vediamo
quando quando apriamo il file con un editor per file 'binari' (per
esempio 
edit.com
 per Windows95). 
Consideriamo n permutazioni definite nell'insieme {0,1,...,254,255}.
Si prenda il primo blocco del file da crittografare e si prenda la
prima permutazione.
A tale blocco del file corrisponde un simbolo e quindi un intero tra 0
e 255; applichiamo la prima permutazione a tale intero ottenendo un
altro intero tra 0 e 255; scriviamo il simbolo corrispondente  a
quest'ultimo intero nel primo blocco del file 'crittografato' di
arrivo.
Si prenda il secondo blocco del file da crittografare; si prenda la
seconda permutazione; applichiamo la seconda permutazione al numero
associato al secondo blocco otteniamo un valore numerico; si scriva il
simbolo di tale valore numerico nel secondo blocco del file
'crittografato'. E così via fino alla posizione n; alla posizione n+1
si riprende la prima permutazione e si agisce come nel primo blocco
del file da crittografare e così via fino a quando si incontra EOF nel
file di partenza.
Per decrittografare un file basta disporre delle permutazioni che
hanno crittografato tale file, trovare le permutazioni inverse e
applicare al file crittografato tali permutazioni per un ulteriore
crittografia (sempre con li metodo precedente) e si ottiene il file
decifrato.
Per quanto riguarda le possibili combinazioni, una chiave con 50
permutazioni (un file di circa 13 KB) mi sembra che ammetta (256!)^50
(circa 4x10^34000) altre possibili chiavi. 
Penso che se le possibili chiavi aumentano troppo è impossibile
rompere il sistema di crittografia poiché a un file potranno
corrispondere più file possibilmente ricavati dal file di partenza,
che hanno senso (a meno che si disponga di MB di messaggi
crittografati con la stessa chiave).
Nel programma ho usato una funzione aggiuntiva per generare numeri
pseudo casuali per assegnare ad ogni blocco del file di partenza una
permutazione scelta ‘a caso’ tra quelle della chiave. Tale funzione
ritorna sempre una stessa successione di numeri a partire da un numero
di partenza nex_t (i numeri da cui poter *iniziare* sono più di 65000)
se tale successione di numeri si ripete per ogni elaboratore e per
qualunque valore iniziale, il programma è portabile.
Il punto debole del procedimento potrebbe essere la generazione di
numeri casuali (per fare permutazioni casuali) poiché la successione
di numeri prodotta dal generatore a partire da un determinato numero
(seed) è sempre la stessa quindi si può riprodurre. (E’ per porre
rimedio a tale inconveniente che si è trattato nel seguito qualche
generatore di numeri casuali che tenta di aggirare i problemi).
[cut]
  2.  TRASLAZIONI, PERMUTAZIONI E  NUMERI  PSEUDO-CASUALI
2.1 Descrizione
I generatori di numeri ‘casuali’ ci servono per costruire delle
permutazioni sull’insieme  {0, 1, ...254 , 255}  (che è come
rimescolare un mazzo di carte numerate da 0 a 255). 
Le funzioni o le procedure sono caratterizzate dal fatto che a un
determinato input esse generano sempre lo stesso output (o risultato)
quindi conoscendo la funzione o la procedura il comportamento di
output sarà facilmente prevedibile. Il nostro problema consiste
proprio nel trovare una funzione di numeri casuali difficilmente
prevedibile quindi per la proposizione precedente tale funzione deve
avere un numero, il più grande possibile, di valori accettabili di
input.
[cut]
Il terzo generatore di numeri pseudo-casuali qrand() [scelta c del
programma proposto] trasla l’iniziazione del generatore rand() di una
quantità che legge da un file (che chiamiamo ausilio) formato da
caratteri scelti a caso (per esempio costruito crittografando con
molte permutazioni un file abbastanza grande).  Conviene associare ad
ogni copia del programma che produce chiavi un file ausilio diverso.
[cut]
Descrizione della procedura: qrand() si legge un intero di 16  bit da
detto file ausilio, legge il valore restituito dal generatore rand()
(inizializzato con un valore dipendente dal tempo [seed=time(NULL);
srand(seed)], fa una traslazione tra i due valori, ottiene un numero
con cui inizializza rand(); restituisce rand(). Se chiamata qrand()
restituisce rand() ancora nove volte, alla decima legge un altro
intero di 16 bit dal file, legge il valore restituito da rand(), fa
una traslazione dei due valori, inizializza rand() con tale
traslazione; restituisce rand(). Restituisce rand() altre nove volte
alla decima ecc. 
[cut]
La speranza è quella di riuscire a fare un generatore non prevedibile
ma tali generatori potrebbero produrre successioni numeriche in cui
non viene rispettata la equiprobabilità.  

elementi.
in altre parole il mio problema è il trattare un vettore di 2^128
puntatori di puntatori a char, e di 2^128 stringhe di dimensione
variabili tra 1 e 32 posti (memoria) . Ed elaborare 2^128 blocchi con
la chiave pubblica (velocità di elaborazione).


 la chiave pubblica (velocità di elaborazione).
Non sono sicuro di aver capito. Comunque quello che intendeva dire
Nicola è questo. A parità di chiave di codifica e di algoritmo, se
codifichi due volte lo stesso messaggio di, supponiamo, 128 caratteri di
lunghezza, ottieni entrambe le volte lo stesso messaggio codificato
lungo sempre 128 byte. Questo va bene. Ma supponi di codificare, sempre
con la stessa chiave e lo stesso algoritmo, un altro messaggio di 128
byte che è identico al primo in tutto e per tutto tranne che nel 35 simo
carattere. Il messaggio codificato sarà anch'esso uguale al primo ...
tranne che nel 35 simo carattere.
In altre parole il valore di un dato carattere del messaggio originale è
codificato in un solo carattere del messaggio finale. Questo rende il
tuo sistema attaccabile con metodi statistici.
Modificando leggermente l'algoritmo potresti ottenerne uno che
genererebbe un messaggio codificato che cambia non solo nel 35 simo
carattere ma anche in quelli successivi (per esempio se fai uno
scrambling delle chiavi ogni volta che codifichi un carattere e usi il
carattere stesso come seme dello scrambling). Ma anche in questo caso
resteresti attaccabile con metodi statistici (solo ci vorrebbe qualche
calcolo in più per applicarli).
Potresti anche lavorare a blocchi di 128 caratteri e fare si che ci sia
uno scramble posizionale. Per cui due messaggi originali che
differiscono in un solo carattere darebbero due digest in uscita che
differiscono in un solo carattere ma che non si trova nella stessa
posizione. Ma anche in questo caso resteresti sempre e comunque
attaccabile con metodi statistici.
Quello che un buon sistema fa (per esempio l'RSA) è che codificando due
messaggi originali identici tranne che per un solo carattere, i digest
in uscita sono totalmente decorrelati (differiscono per un numero
relativamente alto di bit che sono sparsi per tutto il blocco. Il numero
di bit che cambiano è apparentemente casuale e altrettanto la loro
posizione).


tuo sistema attaccabile con metodi statistici.
e se faccio una compressione (.zip) e mando il messaggio compresso?


Io lo intercetto lo decomprimo e poi .....
Io per sicurezza farei cosi':
Lo critterei con il tuo metodo, poi un bel colpo di 3DES e vai
che e' una meraviglia.....
Ciao
Gaetano.
PS: Compra il libro "Applied Cryptography  di A.J Menez ed altri" e
scaricati
un po di materiale da 
www.rsa.com
. Mettendo da parte il sarcasmo, non
demordere ma prima fatti un'idea di come un algoritmo (non l'implementazione
come stai cercando di fare tu) di cripting vada validato.
Dopo che un algoritmo viene accettato allora per quanto riguarda
l'implementazione quella viene solo certificata.




il mittente
testo o binario (testo.txt)-> comprime (testo.txt.zip) ->
crittografa-> invia
il ricevente
riceve -> decifra -> decomprime -> legge
(come il PGP)
e i metodi statistici dovrebbero avere delle difficoltà

 wrote in message
news:3bea29c...@news.tin.it...

Crittazione è una cosa, compressione è un'altra. L'algoritmo usato deve
essere per definizione conosiuto. Solo la chiave può essere (totalmente
o parzialmente) segreta. Se il messaggio è compresso, essendo
l'algoritmo di compressione/decompressione conosciuto, basta
decomprimerlo. E a questo punto cominci l'attacco statistico.
Sarebbe come dire che il digest che è binario lo trasferisci tramite
UUENCODE. Non cambia nulla. Compressione e codifica sono passi che
possono essere svolti senza problemi da chiunque conosca l'algoritmo. E
dato che per definizione gli algoritmi sono pubblici ...


 wrote in message
news:3bea7ba...@news.tin.it...

Nel senso che serve più potenza di calcolo e che gli algoritmi di
attacco statistico sono più complicati, si. Ma la difficoltà della
decrittazione non cambia. Solo la complessità dell'algoritmo di
decrittazione cambia. Inoltre potresti avere anche un piccolo lato
positivo dato che la compressione a sua volta si basa su concetti di
ridondanza e quindi ti ritrovi con un file che oltre ai dati contiene
anche delle informazioni statistiche precalcolate!!


 wrote in message

se è solo questo, si potrebbe usare il blocco di 10 bit (invece che 8
bit quindi le permutazioni non sono di 2^8=256 elementi ma 2^10=1024
elementi) quindi una lettera allo stesso posto avrebbe una
rappresentazione diversa; e la crittoanalisi (insieme alle vostre
osservazioni) va dove deve andare :-)))
Si potrebbe far variare lo schema della lettura della chiave
scrivendo il numero dello schema crittografato con la prima
permutazione.
A questo punto potete inviare un tot (>100 di (1/2)MB con chiave di
1MB ) di messaggi (avendo messaggio e sua traduzione) senza
ricostruire la chiave, ne voi ne i vostri "grandi professori" dei miei
stivali.
Ma il metodo è lo stesso cambia solo la grandezza del blocco  e dove
si scrive lo schema bb per leggere la chiave (prima nella chiave ora
nel file)
Rosario


Che ti stai illudendo parecchio.
pensa per te


>e' difficile che tu ti svegli una mattina con la soluzione, no?
Siamo a conoscenza della chiave pubblica (x^d) mod(n) e della
grandezza del blocco: h bit
sarebbe bello poter definire la funzione r come un *vettore*
 
int_h  r[2^h], i;//intero di h bit es. h=8 o h=128 oppure h=1024 ...  
for(i=0;i<2^h; i++ ) r[(x^d) mod(n)]=x ;
[sarebbe bello poiché i tipi int_h mi sembrano che non esistono nel C
inoltre io utilizzo le stringhe di caratteri numerici=(x^d) mod(n)
come label per poter individuare l'elemento puntato ma in C le uniche
label ammesse sono 0, 1, 2, ... e non caratteri; 
sapete costruire delle funzioni *carricate interamente in memoria*
che associano gli elementi di un insieme di stringhe a numeri [o
vettori di stringhe] il cui dominio sia, ammettiamo 10000000
stringhe?Costruire vettori-funzioni di questo tipo potrebbe essere
utile anche per risolvere altri problemi ]
infatti se y=x^d mod(n) è x cifrato con la chiave pubblica
r[y]=r[x^d mod(n)]=x
e siamo riusciti a ritrovare x senza essere a conoscenza di x^e mod(n)
chiave privata. 

for(i=0;i<2^h; i++ ) r[(x^d) mod(n)]=x ;
scusate: for(x=0;x<2^h; x++ ) r[(x^d) mod(n)]=x ;

Vuoi gestire 10 000 000 di stringhe e raggiungerle velocemente???
è questo che vuoi fare?
e perchè non costruisci una funzione che te lo permette..dov'è il problema?
duido
-- 
Posted from  [62.98.90.244] 


Giuseppe, mi sa che se vai avanti ti prendono di mira e ti prenderanno in giro
per la vita...
Pure io ho chiesto un po' in giro e mi sono informato, ma fidati...si riesce a
decrittare tutto...se te lo dico io che sono un comune mortale...
mi sono fatto un semplice algoritmo di criptaggio e posso garantirti che non lo
do a nessuno e nessuno
saprà decrittare i miei file...così va la sicurezza.
fatti un algoritmo pure tu e tienitelo per te, nessuno riuscirà a decrittare i
tuoi file e la privacy è garantita.
Perderci troppo la testa quando ci sono matematici che si divertono a provare a
rendere pubblico
qualcosa di privato..eh eh...fusion bye bye raga
ciao duido
-- 
Posted from  [62.98.33.5] 



Ciao a tutti, ho un problema che non riesco a risolvere,
questo frammento di codice deve generare 4 tabelle con 256 caratteri
sparsi
casualmente e ogni tabella descrive tutti i 256 caratteri ASCII.
Risultato del seguente Š che il carattere 13 Š presente 8 volte
anzichŠ 4 come
dovrebbe...
trovo strano che fwrite() scriva 1028 char, infatti, ne determino con
sizeof(a)
soltanto 1024 cioŠ 256*4
spero qualcuno sappia aiutarmi, intanto riprover• a verificare il
tutto per la
milionesima volta...
grazie a tutti duido.
PS: nel post che segue scrivo il codice per verificare il contenuto
	del file che abbiamo creato.
/*	PASSAGGI PROGRAMMA GENERA TABELLE:
	verifica[] 	Š l'indice dei caratteri gi… generati
	controllo 	mi permette l'inversione della verifica[]
presenze
	c			sono le tabelle da generare
	ax			Š il carattere generato dinamicamente
	a[][]		Š l'array che contiene le mie 4 tebelle con
256 caratteri ciascuna
*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define POSIZIONE_CODICE "c:\\codice.txt"
void main(void)
{
   FILE *codice;
   unsigned char a[4][256],controllo,verifica[256];
   unsigned int x,c,ax;
   if((codice=fopen(POSIZIONE_CODICE,"w"))!=NULL){
                                         clrscr();
	printf("\n\n\n\n\tSto creando la tabella di
                                 traduzione.\n\n\n\n\tattendere...");
	for(x=0;x<256;x++)	
//azzero il controllo per la verifica presenza deicaratteri creati
			verifica[x]=0;
        controllo=1;
		for(c=0;c<4;c++){	//GENERO LE 4 TABELLE 
			randomize();
			for(x=0;x<256;x++){
                                     //genero 255 caratte ridiversi
				do{
			for(ax=256;ax>255;ax=rand()%1000);	 
                                             //genero il carattere
                                              buf=(unsigned char)ax;
				}while(verifica[ax]==controllo);
				if(controllo)       
//confermo come carattere gi… presente
					verifica[buf]=1;
				else
					verifica[buf]=0;
				a[c][x]=(unsigned char)ax;
//copio il carattere nella tabella
			}
			if(controllo)	//inverto il controllo
				controllo=0;
			else
				controllo=1;
		}
		fwrite(a,sizeof(a),1,codice);	//tabella traduttiva
 
		fclose(codice);
		printf("\n\n\n\n\n\n\n\n\tTabella creata premi INVIO
per continuare...");
		getch();
	}
	else{
		printf("\n\n\n\n\n\tImpossibile creare il file
tabella.");
		printf("\n\n  premi INVIO per uscire dal
programma...");
		getch();
        exit(0);
    }
}
-- 
Posted from 
ppp-218-21.30-151.libero.it
 [151.30.21.218] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG
_____________________________________________
?
Evidentemente volevi controllare  file di permutazioni (forse
**chiavi** per programmi di crittografia) per vedere che
effettivamente erano permutazioni. 
Come è piccolo il mondo .))) !
Ma dimmi ti dispiace che penso anche all'RSA oltre che alla
crittografia o non te ne frega niete?

qualcosa di privato..eh eh...fusion bye bye raga
guarda che per me imparare il C (o fare algoritmi di crittazione) sono
"passeggiate di salute" rispetto a quello che facevo prima (&& || =>
ecc). Per quanto riguarda i tuoi amici matematici forse ho una mezza
idea sul giochino irrisolvibile con cui potranno trastullarsi per un
po' di tempo
Ciao


giuseppe mi piacerebbe continuare la conversazione nel NG
apposito...spoostiamoci su it.comp.sicurezza.varie
cosa ne dici?
duido
-- 
Posted from  [62.98.91.89] 


Ignorio quel problema l'ho risolto staccando la generazione di una nuova
tabella
con un for() che perdesse un po' di tempo...
cmq rileggendo mi sono sembrato troppo duro..scusa.
le tabelle di grandi dimensioni le gestisco molto bene (memoria permettendo)
con una tabella hash con una funzione di ricalcolo hash che non ricalcola ma
porta alla posizione, questo mi risolve le enormi collisioni rendendo tutto +
veloce.
duido
-- 
Posted from  [62.98.91.89] 


   if((codice=fopen(POSIZIONE_CODICE,"w"))!=NULL){
forse il compilatore tratta il numero del carattere "ritorno a capo"
come due caratteri il 13 e il 10

cosa ne dici?
Che declino l'invito 

cmq rileggendo mi sono sembrato troppo duro..scusa.
ok scusato

stivali.
scusate qui ho sbagliato in toto, chiedo scusa.
Nessuno è perfetto e non credo di essere meglio degli altri (ognuno ha
la sua gobba) :)
Rosario