Newsgroup: it.istruzione.scuola
Titolo: [OT]crittosfida

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 :-(( ) ?
Che ti stai illudendo parecchio.


                   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à.  

Che ti stai illudendo parecchio.
pensa per te


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] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

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] 


cosa ne dici?
Che declino l'invito