Newsgroup: it.comp.lang.c
Titolo: Questo prog. genera un file potenzialmente indecrittabile(a meno di non conoscere la chiave)?

Ho appena finito un prog. che xora byte per byte un file di testo con una
chiave random di lunghezza pari al file....
La chiave random è generata dalla funzione rand() con il tempo come seme....
Ecco qui il prog:
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MAX 256
void genera_chiave(void);
void leggi_file_origine(void);
void cifra(void);
int menu(void);
void leggi_file_crittato(void);
char x;
char file_origine2[MAX];
FILE *file_origine;
FILE *file_destinazione;
FILE *chiave_cifratura;
int posizione;
main()
{
 system("cls");
 puts("\n\n\n\n\tQuesto prog. cripta un file \"xorandolo\" carattere per
carattere");
    puts("\tcon una chiave random di lunghezza pari al file da
criptare....");
    puts("\tIl file potra' essere in seguito decriptato con la chiave
random");
    puts("\tgenerata precedentemente e che il prog. salva sul file
chiave.txt");
    puts("\tAttenzione! Questo prog critta solo file di
testo(.txt,.html,ecc)");
 puts("\tNiente file di word, excel, access o binari...");
 puts("\tA causa della lentezza nella generazione della chiave le
dimensioni");
 puts("\tdel file da criptare non possono superare i 980Kb(2 minuti e
mezzo");
 puts("\tcirca per generare una chiave di tali dimensioni)");
 puts("\tCerchero' di porre rimedio nelle prossime release(se ce ne
saranno!)");
 puts("\tA breve cerchero' anche di inserire la possibilita' di criptare
file");
 puts("\tbinari");
 printf("\n\n\t\t\tPremere un tasto per continuare");
 getch();
 menu();
 switch(x)
 {
  case'1':  fflush(stdin);
     leggi_file_origine();
     genera_chiave();
     cifra();
     break;
  case'2':  fflush(stdin);
     leggi_file_crittato();
     break;
  case'3':  puts("\nCazzo!");
     break;
  default:  break;
 }
 return 0;
}
void genera_chiave(void)
{
 int caso;
 int chiave;
 long i;
 puts("\n\n\tGenerazione chiave....");
 chiave=posizione;
 srand((unsigned) time(NULL));
 chiave_cifratura=fopen("c:\\windows\\desktop\\chiave.txt","w");
 i=0;
 while(i<posizione)
 {
  caso=rand();
  if (caso<200 || caso>=255)
    {
    continue;
   }
  else
   {
    fputc(caso,chiave_cifratura);
   }
 i++;
 }
fclose(chiave_cifratura);
}
int menu(void)
{
 system("cls");
 printf("\t\t\t\t\tMENU:");
 printf("\n\n\t1) Critta");
 printf("\n\t2) Decritta");
 printf("\n\t3) Esci");
 x=getch();
 return(x);
}
void leggi_file_origine(void)
{
 char leggi[MAX];
 int i=0;
 system("cls");
 printf("\n\n\tFile da crittare: ");
 gets(file_origine2);
 puts("\n\n\tLettura file origine....");
 file_origine=fopen(file_origine2,"r");
 if (file_origine==NULL)
  {
   fprintf(stderr,"\nErrore nell'apertura file o file inesistente");
   exit(1);
  }
 while(!feof(file_origine))
  {
   fgets(leggi,99,file_origine);
   }
 posizione=ftell(file_origine);
 if (posizione>1000000)
  {
   fprintf(stderr,"\n\n\tSpiacenti, il file in questione supera la
dimensione critica");
   getch();
   exit(1);
  }
 fclose(file_origine);
 }
void cifra(void)
{
 char file[MAX];
 int i;
 int leggi_file_origine;
 int leggi_chiave_cifratura;
 int risultato;
 system("cls");
 printf("\n\nInserire nome e percorso del file di destinazione: ");
 gets(file);
 puts("\n\nGenerazione file crittato in corso....");
 file_destinazione=fopen(file,"w");
 file_origine=fopen(file_origine2,"r");
 chiave_cifratura=fopen("c:\\windows\\desktop\\chiave.txt","r");
 for(i=0;i<posizione;i++)
  {
   leggi_file_origine=fgetc(file_origine);
   leggi_chiave_cifratura=fgetc(chiave_cifratura);
   risultato=leggi_file_origine^leggi_chiave_cifratura;
   fputc(risultato,file_destinazione);
  }
 fclose(file_origine);
 fclose(file_destinazione);
 fclose(chiave_cifratura);
}
void leggi_file_crittato(void)
{
 FILE *fp1;
 FILE *fp2;
 FILE *fp3;
 char leggi3[MAX];
 char file_crittato2[MAX];
 char file_destinazione[MAX];
 char file_chiave[MAX];
 int lunghezza;
 int i;
 int leggi_file_origine2;
 int leggi_chiave_cifratura;
 int risultato;
 system("cls");
 printf("\n\nInserire nome e percorso del file crittato: ");
 gets(file_crittato2);
 fp1=fopen(file_crittato2,"r");
 if (fp1==NULL)
 {
  fprintf(stderr,"\nErrore in apertura file o file inesistente");
  exit(1);
 }
 printf("\nInserire nome e percorso della chiave:");
 gets(file_chiave);
 fp2=fopen(file_chiave,"r");
 if (fp2==NULL)
  {
   fprintf(stderr,"\nErrore in apertura chiave di cifratura o file
inesistente");
   exit(1);
  }
 printf("\n\nInserire nome e percorso del file di destinazione: ");
 gets(file_destinazione);
 fp3=fopen(file_destinazione,"w");
 puts("\n\nLettura file crittato in corso...");
 while(!feof(fp1))
 {
  fgets(leggi3,99,fp1);
 }
 lunghezza=ftell(fp1);
 rewind(fp1);
 puts("\n\nLettura file crittato in corso....");
 puts("\nLettura file chiave in corso....");
 puts("\nGenerazione file originale in corso....");
 for(i=0;i<lunghezza;i++)
  {
   leggi_file_origine2=fgetc(fp1);
   leggi_chiave_cifratura=fgetc(fp2);
   risultato=leggi_file_origine2^leggi_chiave_cifratura;
   fputc(risultato,fp3);
  }
 fclose(fp1);
 fclose(fp2);
 fclose(fp3);
}
E' esatto dire che se non possiedi oltre al file crittato il file con la
chiave il file crittato è potenzialmente indecrittabile?
Vi ho scritto anche per esporvi un problema che ho riscontrato:
La chiave random impiega troppo tempo a formarsi in file di medie
dimensioni(400kb-900kb)....
Questo perchè ho dovuto aggiungere un if che scartasse i numeri superiori a
255 e inferiori a 200 per evitare sorprese(caratteri indecrittabili)....
C'è un modo di velocizzare il tutto?
Non so come limitare il RAND_MAX: qualcuno sà come fare?
Grazie a tutti per una eventuale risposta....
Steve

 RAND_MAX: qualcuno sà come fare?
	char my_random_char=rand()%255;
	Alla prossima,
		Marco

  Direi di si`, potenzialmente e` indecrittabile. ;)
io scommetto che riesco a decrittarlo, invece.
la chiave che usi, in realta', non e' di lunghezza
infinita, ma e' di (suppongo) 32 bit. (se non meno)
decrittare il tuo file scegliendo una chiave a caso e
per i primi bytes richiederebbe veramente poco
tempo... supponiamo 1 millesimo di secondo.
verificare tutte le chiavi candidate significherebbe
impiegare 1 mese circa.
Oha
-- 
#include <disclaimer.h>

 io scommetto che riesco a decrittarlo, invece.
  Abbiamo detto "potenzialmente". ;)
	Alla prossima,
		Marco

 Non so come limitare il RAND_MAX: qualcuno sà come fare?
?
se tu hai "unsigned char caso=rand();"
di rand() viene preso il byte - significativo;
ciao


  Abbiamo detto "potenzialmente". ;)
io dico palesemente crackabile, invece ;)
Oha
-- 
#include <disclaimer.h>

 io dico palesemente crackabile, invece ;)
  Il "potenzialmente" e` riferito al fatto che non ho esaminato il
codice. Se veramente, come lui sostiene, usa un algoritmo one-time-pad,
non vedo come possa decrittarlo, visto che quello che ti arriva e` solo
spazzatura. Se invece millanta solo di usarlo, allora puoi farne cio`
che vuoi. ;)
	Alla prossima,
		Marco
PS Eventualmente, mi trovi su IRC.

Ecco qui il prog:
No no aspetta un attimo stai seguendo un criterio sbagliato....
intanto una password lunga come un file e' quanto di + scomodo si
possa pensare inoltre il rapporto fra chaive e tempo non e'
affidabile.
Ti consiglio di optare per una chiave + corta e generata a partire
magari da sequezne di tasti casuali premuti dall'utente che vanno a
interagire con un file di testo a caso scelto dall'utente.
Se poi vuoi continuare ad usare una chiave lunga allora dovresti
poterla far salvare/leggere da dischetto...cosi' almeno la chiave da
oggetto teorico diventerebbe effettivamente "hardware"
Augusto Pucci
Webmaster di Prospektiva On-line
http://www.prospektiva.it

  Direi di si`, potenzialmente e` indecrittabile. ;)
Sbagliato in realta' l'uso del semplice xor non garantisce una soglia
sufficiente di sicurezza...non a caso anche il evcchio des sfruttava
le sue celle di scambio oltre agli xor


 che vuoi. ;)
Il fatto è che gli algoritmi random sono basati su calcoli con variabili e
testando quelli iniziali
alla fine si decritterebbe (scusa se non mi spiego bene, guarda la mia
risposta)
ciao

 oggetto teorico diventerebbe effettivamente "hardware"
Grazie a te e a tutti voi per l'aiuto!
Effettivamente avere una chiave lunga come il file non č il massimo della
vita!
^___^
Questo prog. l'ho fatto soprattutto per imparare a gestire correttamente i
flussi di scrittura/lettura su file....(č da un mese che mi diletto sul C)
La crittografia mi ha sempre affascinato, e cosě ho pensato di provare a
fare qualcosa di un po' + complesso  che spostare le lettere di 13
posizioni(algoritmo di Cesare)....
Quello che suggerisci č una buona idea: magari quando imparerň anche
qualcosa sul teorema di Eulero e sulle matrici cercherň di provare
qualcos'altro!
Grazie ancora per le risposte....
Steve

 tempo... supponiamo 1 millesimo di secondo.
Anche questo non lo ho capito.... anche usando la forza bruta, come fai a
capire quando ha decrittato i primi byte?

 decritterebbe (scusa se non mi spiego bene, guarda la mia risposta)
  No, ti sei spiegato bene (ma la tua risposta l'avevo gia` letta). ;)
  Il problema e` nel "pad": basta usare una chiave sufficientemente
"random" e non sara` possibile analizzare il testo crittografato
(potenzialmente, dunque). 
  La sequenza che segue rappresenta i codici ASCII in esadecimale di una
piccolissima frase di Einstein crittografata mediante l'XOR con un pezzo
di un help-on-line di Windows 95. I caratteri di newline dell'input sono
stati copiati inalterati nell'output. ;)
<crypt>
	12 0c 01 4f 14 1e 04 43 1b 03 07 07 04 00 09
	4f 53 16 45 20 23 41 2d 2c 36 0a 69 1a 49 15  
	07 10 40 41 05 13 04 11 18 06 43 04 00 03 0c 
	1b 16 1b 0f 06 4c 0c 0a 23 15 45 1c 00 4e 4f 
	54 13 03 1c 57 06 4e 07 00 1f 1e 03 49 07 0c
</crypt>
	Alla prossima,
		Marco

ciao
In questo caso fosre si (anche se ammetto di non aver letto il progr
in questione nel dettaglio) ma nulla ti vieta di far shiftare
l'applicazione della chiave xor in dipendenza della chiave xor
stessa...risultato : sovrapposizione della chiave con se stessa e
impossibilita' di decifrare tutto da un singolo brandello...poi in
questo caso se non erro la chiave era lunga come tutto il file quindi
il problema della crittana,isi parziale nmeppure si poneva


Steve
Comunque ascolta, se ti interessa la crittografia e la crittanalisi er
vuoi un approccio morbido leggiti quel libro che citavo prima
("Segreti Spie Codici Cifrati") divertente, chiaro, non troppo tecnico
ma rigoroso.
Ah, un altra cosa l'idea della chiave lunga come il file di suo non e'
malaccio, solo che dovresti correggere il tiro... ti consiglio di
usare una chiave (se vuoi fare esperimenti estremi) lunga al massimo
1,44 Mb memorizzata su dischetto... nella pratica e' un approccio
certamente + pratico che doversi ricordare una apssword... anche se
lento (data la lentezza delle letture da floppy) da considerare pero'
che nessuno ti vieta di predisporre un array lungo 1,44 x 1024 x 1024
bytes +1 byte per il terminatore. Cosi' la lentezza sarebbe solo nel
caricamento in memoria del file chiave.
Da notare che puoi anche trovare un compromesso fra le due cose..con
chiavi comunque molto grandi.
Ricorda epro' che non sempre las lunghezza della chiave e' sinonimo di
qualita' infatti se esegui uno xor e nulla + esistono tecniche di
crittoanalisi (che tengono conto fra le altre cose dell'occorrenza dei
simboli et similia) che eprmettono di facilitare l'approccio a forza
bruta... buona fortuna col C :-)


 il problema della crittana,isi parziale nmeppure si poneva
non ho capito molto bene cosa intendi, ma si parlava di ricavare la chiave
dal seed iniziale, percui trovato quello e conoscendo l'algoritmo di
randomizzazione
si ricava la chiave.
o meglio si provano + seed iniziali che possano corrispondere alla data e si
cerca
una parte di chiave. con questo si decifra un parte del file e si vede se la
chiave è corretta.
Se va male (il seed non èstato scelto con la data) ci sono 4 miliardi e
rotti di possibilità,
ma altrimenti anche se si sa solo il giorno, basta provare con 1.572.480 di
combinazioni.
Mi è sorta poi una domanda: ma con questo tipo di crittazione ha senso
parlare di file crittato
e di chiave? o i due termini sono interscambiabili?

Scusa ti posso fare solo una domanda?
Ho modificato il prog e gli ho aggiunto la possibiltà di generare una chiave
casuale di dimensioni definite dall'utente e poi di crittare + file con
quella stessa chiave....
Domanda: se la chiave è molto + piccola del file crittato(esempio 5000 byte)
e il file crittato è di 1,44 Mb, ci sono sempre le possibili combinazioni
che hai detto tu oppure molte di meno?(scusa la pessima esposizione, e
grazie ancora per le spiegazioni date)
Da quel che ho capito una volta che conosci quando è stata generata la
chiave è facile risalire all'intero file crittato....
Se vuoi ti posto il programma: non lo posto qui perchè è un po' lunghetto(11
kb + o meno)....
Domanda N2: Se al posto di random generassi la chiave in base a una
combinazione di tasti inseriti dall'utente(300 o 400 caratteri per esempio)
allora decrittare il file sarebbe molto + complicato giusto?
Grazie per le eventuali risposte....
Steve

e di chiave? o i due termini sono interscambiabili?
No non sono interscambiabili anche perche' la conoscenza della chiave
non ti permetterebbe di ricavare direttamente il documento...si tratta
di una chiave xor, non di una impronta.


chiave č facile risalire all'intero file crittato....
Ma scusami un attimo... ma chi te lo fa fare di indebolire il tuo
algoritmo ?
La debolezza intrinseca del tuo algoritmo e' il legame che c'e' fra
chaive e ora/data generazioine della chiave..semplicemente..elimina
questa dipendenza :-)
Potresti far si che la chiave venga generata a partire da : pressione
tasti casuale, secondi in cui vengono rpemuti i tasti, secondi che
passano tra una pressione di tasti e un altra.
Meglio ancora sarebbe far scegliere all'utente direttamente la chiave
per pressione tasti... am questo vorrebbe dire far pigiare 100 tasti
per una chiave da 800 bit...il che comunque sarebbe accettabile :-)


 per una chiave da 800 bit...il che comunque sarebbe accettabile :-)
Il problema č che lo xor non funziona per tutti i caratteri ascii scelti,
nel senso che non puoi sempre decrittare quello che hai crittato(non so il
perchč)
Devo trovare qualche altra maniera....
Il programma che ho fatto io poi non decritta correttamente i caratteri
accentati...
Devo guardarci su...
Ciao e grazie
Steve

perchè)
??? ma hai usato l'operatore ^ ? Dovrebbe funzionare...ma xche' lo
vuoi usare per testi in mod ascci ? Non e' + conveniente se usi fopen
in modalita' binaria e poi lavori sempre su 1byte alla volta ?


 di una chiave xor, non di una impronta.
in effetti è vero

 Steve
ciao

 capire quando ha decrittato i primi byte?
per un file di testo basterebbe controllare che sono presenti solo caratteri
"validi"
per un testo. Per files binari c'è sempre un'intestazione che può essere
trovata anche + rapidamente
ciao

in effetti č vero
Tra l'altro anche l'impronta non ti permette di ritrovare il documento
essendo realizzata generalmente con funzioni "trappola"... ad esempio
le funzioni della famiglia hash


 solo lo xor)
io parlavo dell'algoritmo proposto da Steve
ciao

intendevo VERAMENTE casuale (scelta dall'utente)
etc..etc...
No scusa.. ma mi sa che stiamo facendo un sacco di confusione... a
quale programma di cifratura ti stai riferendo ? (xche forse stiamo
aprlando di due cose diverse).
Io mi riferivo al programma il cui sorgente era stato qui postato che
consisteva originariamente in uno xor semplice con chiave generata in
dipendenza da data/ora.
Poi il problema si e' riformulato con un programma che xorava (bello
sto verbo .-) ) con chiave lunga quanto tutto il fiel indipendente da
data e ora ma dipendente solo da una sequenza di tastoi premuti.
Cio' comportava passowrd lunghjissime da memorizzare su
dischetto...ora un sistema simile e' in effetti impernetrabile (salvo
improponibili attacchi a forza bruta).
Per quanto riguarda la decrittazione della prima parte..bhe in uncaso
cosi' non ti servirebbe a nulla individuare il seme..semplciemente
xche un seme non c'e' :-)
Mi sa che prima stavamo sovrappinendo due discorsi diversi giusdto ?


 dipendenza da data/ora.
Ho anche modificato il vecchio prog.... Ora critta anche i binari,  i jpg ,
i doc, ecc...
Ah ho capito perchè non sempre mi funzionava lo xor: in modalità ascii
alcuni caratteri vengono interpretati(tipo control k), in binario sono
scritti così come sono....
Eccolo:
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MAX 256
void cifra_con_chiave_predefinita(void);
int menu(void);
void leggi_file_crittato_con_chiave_predefinita(void);
char x;
char file_origine2[MAX];
FILE *file_origine;
FILE *file_destinazione;
FILE *chiave_cifratura;
int posizione;
main()
{
 system("cls");
 puts("\n\n\n\n\tQuesto prog. cripta un file \"xorandolo\" carattere per
carattere");
    puts("\tcon una chiave random di lunghezza pari al file da
criptare....");
    puts("\tIl file potra' essere in seguito decriptato con la chiave
random");
    puts("\tgenerata precedentemente e che il prog. salva sul file
chiave.txt");
    puts("\tAttenzione! Questo prog critta solo file di
testo(.txt,.html,ecc)");
 puts("\tNiente file di word, excel, access o binari...");
 puts("\tA causa della lentezza nella generazione della chiave le
dimensioni");
 puts("\tdel file da criptare non possono superare i 980Kb(2 minuti e
mezzo");
 puts("\tcirca per generare una chiave di tali dimensioni)");
 puts("\tCerchero' di porre rimedio nelle prossime release(se ce ne
saranno!)");
 puts("\tA breve cerchero' anche di inserire la possibilita' di criptare
file");
 puts("\tbinari");
 printf("\n\n\t\t\tPremere un tasto per continuare");
 getch();
 menu();
 switch(x)
  {
   case'1': cifra_con_chiave_predefinita();
      break;
   case'2': leggi_file_crittato_con_chiave_predefinita();
      break;
   case'3': puts("\n\nCiauz!");
   default: break;
   }
 return 0;
}
int menu(void)
{
 system("cls");
 printf("\t\t\t\t\tMENU:");
 printf("\n\t1) Critta, ma con chiave predefinita");
 printf("\n\t2) Decritta, ma con chiave predefinita");
 printf("\n\t3) Esci");
 x=getch();
 return(x);
}
void cifra_con_chiave_predefinita(void)
{
 FILE *fp;
 FILE *fp2;
 FILE *fp3;
 char file[MAX];
 char file2[MAX];
 char file0[MAX];
 int i;
 int leggi_file_origine;
 int leggi_chiave_cifratura;
 int risultato;
 int dimensione_file_origine;
 int dimensione_chiave;
 system("cls");
 printf("\n\nInserire nome e percorso del file di origine: ");
 gets(file0);
 printf("\n\nInserire nome e percorso del file di destinazione: ");
 gets(file);
 printf("\n\nInserire nome e percorso del file della chiave: ");
 gets(file2);
 puts("\n\nGenerazione file crittato in corso....");
 fp=fopen(file0,"rb");
 if(fp==NULL)
  {
   fprintf(stderr,"\n\nErrore in apertura file origine");
   getch();
   exit(1);
  }
 fp2=fopen(file,"wb");
 fp3=fopen(file2,"rb");
 if(fp3==NULL)
  {
   fprintf(stderr,"\n\nErrore in apertura file chiave");
   getch();
   exit(1);
  }
 fseek(fp3,0,SEEK_END);
 dimensione_chiave=ftell(fp3);
 rewind(fp3);
 printf("%d",dimensione_chiave);
 fseek(fp,0,SEEK_END);
 dimensione_file_origine=ftell(fp);
 rewind(fp);
 printf("\n%d",dimensione_file_origine);
 if(dimensione_chiave>dimensione_file_origine)
  {
  for (i=0;i<dimensione_file_origine;i++)
   {
    leggi_file_origine=fgetc(fp);
    leggi_chiave_cifratura=fgetc(fp3);
    risultato=leggi_file_origine^leggi_chiave_cifratura;
    fwrite(&risultato,sizeof(char),1,fp2);
   }
  exit(0);
  }
 else if(dimensione_chiave<dimensione_file_origine)
 {
 while(!(dimensione_file_origine==ftell(fp)))
  {
   if(ftell(fp3)>=dimensione_chiave)
   {
    rewind(fp3);
    printf("\n%d",ftell(fp3));
   }
   fread(&leggi_file_origine,sizeof(char),1,fp);
   fread(&leggi_chiave_cifratura,sizeof(char),1,fp3);
   risultato=leggi_file_origine^leggi_chiave_cifratura;
   fwrite(&risultato,sizeof(char),1,fp2);
  }
 }
 fclose(fp);
 fclose(fp2);
 fclose(fp3);
}
void leggi_file_crittato_con_chiave_predefinita(void)
{
 FILE *fp1;
 FILE *fp2;
 FILE *fp3;
 char file_crittato2[MAX];
 char file_destinazione[MAX];
 char file_chiave[MAX];
 int lunghezza;
 int lunghezza2;
 int leggi_file_origine2;
 int leggi_chiave_cifratura;
 int risultato;
 system("cls");
 printf("\n\nInserire nome e percorso del file crittato: ");
 gets(file_crittato2);
 fp1=fopen(file_crittato2,"rb");
 if (fp1==NULL)
 {
  fprintf(stderr,"\nErrore in apertura file o file inesistente");
  getch();
  exit(1);
 }
 printf("\nInserire nome e percorso della chiave:");
 gets(file_chiave);
 fp2=fopen(file_chiave,"rb");
 if (fp2==NULL)
  {
   fprintf(stderr,"\nErrore in apertura chiave di cifratura o file
inesistente");
   getch();
   exit(1);
  }
 printf("\n\nInserire nome e percorso del file di destinazione: ");
 gets(file_destinazione);
 fp3=fopen(file_destinazione,"wb");
 puts("\n\nLettura file crittato in corso...");
 fseek(fp1,0,SEEK_END);
 fseek(fp2,0,SEEK_END);
 lunghezza2=ftell(fp2);
 lunghezza=ftell(fp1);
 rewind(fp1);
 rewind(fp2);
 puts("\n\nLettura file crittato in corso....");
 puts("\nLettura file chiave in corso....");
 puts("\nGenerazione file originale in corso....");
 if(lunghezza>lunghezza2)
 while(!(ftell(fp1)==lunghezza))
  {
   if(ftell(fp2)>=lunghezza2)
    rewind(fp2);
   leggi_file_origine2=fgetc(fp1);
   leggi_chiave_cifratura=fgetc(fp2);
   risultato=leggi_file_origine2^leggi_chiave_cifratura;
   fwrite(&risultato,sizeof(char),1,fp3);
  }
 else if(lunghezza2>lunghezza)
  while(!(ftell(fp1)==lunghezza))
  {
   leggi_file_origine2=fgetc(fp1);
   leggi_chiave_cifratura=fgetc(fp2);
   risultato=leggi_file_origine2^leggi_chiave_cifratura;
   fwrite(&risultato,sizeof(char),1,fp3);
  }
 fclose(fp1);
 fclose(fp2);
 fclose(fp3);
}
Scusate per i puts iniziali , sono gli stessi di prima...
Se esaminate il listato comunque vedete che ho solo cambiato il modo di
accesso, lettura e scrittura su file....
Sono contento, ho capito un sacco di cose! :-)
Prossimamente cercherò di fare qualcosa che non si limiti allo xor....
Grazie ancora....
Steve

 80).
[root@fokhouse /root]# man time | col -b | grep -A2 ^DE
DESCRIPTION
       time  returns the time since the Epoch (00:00:00 UTC, Jan
       uary 1, 1970), measured in seconds.
[root@fokhouse /root]#
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

 usarla + corta del file?
[...]
Se non sbaglio, usare un pad per crittare un file e' valido solo se la
pad viene usata una sola volta, in quanto facendo l'xor tra due file
crittati con la stessa pad, mi sembra che si ottenga l'xor tra i due
file di partenza, quindi si elimina la pad...
--
 Ciao, Bianco.
 Reply to 
luca....@tiscalinet.it

[root@fokhouse /root]# man time | col -b | grep -A2 ^DE
DESCRIPTION
       time  returns the time since the Epoch (00:00:00 UTC, Jan
       uary 1, 1970), measured in seconds.
mi sono sbagliato e ho fatto un mix tra clock e time
ciao

 
http://www.prospektiva.it
Mi sa anche a me che abbiamo fatto confusione. Ti ripongo le domande meglio:
1) Nel caso dell'algoritmo one time pad (non di questo programma)
se i valori della chiave sono scelti veramente in maniera casuale,
uno xor semplice dovrebbe andare bene? Se ci pensi TUTTE le chiavi
potrebbero essere valide, o meglio non è possibile ricostruire il file
a partire dal file crittato. (Intendo in teoria, quindi senza recuperare
dati dall'HD, etc).
2)Il programma che richiede una lunghissima chiave all'utente credo che
sia attualmente praticamente invulnerabile con i computer di oggi
(sempre in teoria), con sicurezza crescente man mano che il file è +
piccolo.
3) Invece il programma che crea il seed a partire dall'intervallo della
pressione
dei 2 tasti, è facilmente crackabile. Infatti intendevo la derittazione
della prima
parte in questo algoritmo (o in quello proposto sopra).
ciao

parte in questo algoritmo (o in quello proposto sopra).
Si' pero' se ci aggiuyngi il fattore casuale tasti_premuti diventa una
buona via di mezzo fra totale affidabilita'/difficolta' nel generare
chiavi lunghe e inaffidabilita'/facilita' nel creare chiavi
lunghe..altrimenti dovresti far premere all'utente n tasti con
n=lunghezzachiaveinbit/8
Comuqneu tieni presente che nessun algoritmo di cifratura e'
affidabile al 100% poiche' nessun algoritmo puo' resistere all'attacco
a forza bruta quindi effettivamente la lunghezza della chaive comporta
il fattore discriminante eprt l'affidabilita' dell'algoritmo..tieni
epro' presente che nei casi reali occorre una via di mezzo fra massima
sicurezza e effettiva efficienza


 teoria, quindi senza recuperare dati dall'HD, etc).
  E` banalmente dimostrabile: se f(T,K) e` la funzione di crittazione ed
i domini T e K sono, rispettivamente, il testo in chiaro e la chiave, e`
ovvio che la trasformazione
	T,K ---> C
	     f
e` irreversibile. Anche se f(T,K) fosse una semplice somma tra numeri
naturali, appare evidente l'assunto: 8 e` il risultato di
	1+7
	2+6
	3+5
	4+4
	5+3
	6+2
	7+1
quale scegliere? L'orizzonte computazionale di un eventuale calcolo di
tutte le combinazioni possibili potrebbe andare ben al di la` delle
possibilita` di Deep Thought. ;)
  Il "ma" in tutto il discorso e` il dominio K: se e` possibile trovare
un ordine nei suoi elementi, allora si` che l'orizzonte computazionale
si avvicina, eliminando drasticamente molti dei figli di ogni nodo
dell'albero combinatorio.
  In sostanza, il metodo dell'"one-time-pad" e` sicuro nella misura in
cui e` stocastica la chiave. "Potenzialmente" sicuro, dunque. ;)
	Alla prossima,
		Marco

Sono contento, ho capito un sacco di cose! :-)
Hai visto che in modalita' binaria funzioanno per bene :-)


combinazioni.
dimmi dove abiti, avrei piacere ad avere 1.486.080
secondi in piu' di ora, al giorno. :) (epoch e' in
secondi, non in 18.2esimi di secondo!)
Oha
-- 
#include <disclaimer.h>

casuale se generata da un algoritmo.
un buon sistema di cifratura, oltre ad avere una
chiave di n bits, dovrebbe avere un buon livello di
entropia; l'algoritmo che genera i bit di xor che
verranno applicati al file origine per la cifratura
NON deve essere casuale, ma ripetibile.
molto ricercata dunque e' l'irreversibilita' di una
funzione.
quanto impiego io a calcolare x=a^p%m con unsigned
long long a,p,m?
se io ti dessi a,m e x, quanto impiegheresti a trovare
p?
Oha
-- 
#include <disclaimer.h>

(diciamo 4000 e rotti bit) memorizzate su + file nello stesso
urka! 4000 bits venivano usati nella guerra fredda con
chiavi asincrone!
64bits sono piu' che sufficienti [1] per una sicurezza
casalinga (con un pee-cee di casa, bisognerebbe
aspettare decenni prima di avere CPU sufficiente per
_tentare_ di decifrarlo); 128bits sono praticamente
garantiti a vita ;)
Oha
[1] oviamente, se l'algoritmo e' buono. :)
-- 
#include <disclaimer.h>

p?
Bhe guarda che quk si sta aprlando di un sistema a chiave simmetrica
unica..non asimmetrico...comuqnue la funzione che cerchi
esiste..chiapopi due numeri primi di 90 cifre epr uno li moltiplichi e
almeno che tu non sia Robert Redford 8alzi la mano chi ha caputo la
citazione) o sai la chiave di decodifica o ti attacchi al tram


garantiti a vita ;)
Ma che cavolo dici ???
Mi sa che te stai su un altro paineta non Gibl...guarda che anche il
des e' stato decifreato..e diversi anni fa :-) Poi qui stimao aprlando
di sicurezza ai limiti della partanoia..qui siamo daccordo


 citazione)
[...]
Io! Io! (con la mano alzata) Citazione da "I signori della truffa".
"Ho vinto qualche cosa?" (citazione...) ;-)




Complimenti..pero' non hai vinto nulla :-) (il personaggio si chiamava
Robertino se non erro :-) )


 [1] oviamente, se l'algoritmo e' buono. :)
Cosě come l'ho messo, il mio prog č palesemente cracabile?
O la chiave di 4000 bit gli garantisce un minimo di sicurezza?(a prop: č a
4000 bit giusto? o a 4032(c'č anche il rand() di mezzo))
Per il prog vedi         Steve 18/06/00 22:26
Ciao
Steve

> Cosě come l'ho messo, il mio prog č palesemente cracabile?
Scusate per l'inesattezza.... :D
Il mio prog genera un file crittato palesemente crakabile?

--
Scusate l'ignoranza (mi interessa l'argomento e vorrei qualche consiglio) che
cos'è una "pad"?

Il mio prog genera un file crittato palesemente crakabile?
Bhe palesemente e' una aprola grossa... comunque tieni presente che la
siicurezza di un progr di cifratura si trova supponendo che il codice
sia sempre di pubblico dominio..quindi..bhe un po' si per la
dipendenza con le ore/daye nella prima vers


file di partenza, quindi si elimina la pad...
Ora che ci ripenso credo che tu ti sbagli...non vorrei sbagliarmi io
ma lo xor come funzione dovrebbe essere involutoria si'...ma quello
che dici tu non credo avvenga..almeno che non abbia fatto male la
prova


Per il prog vedi         Steve 18/06/00 22:26
La lunghezza della chaive andrebbe benissimo..e' quel rand() di mezzo
che lo rende super crackabile capito ?


 che lo rende super crackabile capito ?
E io che pensavo l'aumentasse! :D
L'avevo messo apposta per aumentare la casualità(l'utente di solito tenderà
a pigiare una cinquantina di tasti diversi al massimo).....
Comunque con i binari non dovrebbe essere possibile provare a decrittare
parti di codice giusto?
Quindi ci sarebbero 2 alla 4000 possibili crittazioni(teoriche) e anche
supponendo che vengano digitate solo le 26 lettere minuscole dell'alfabeto
il numero di possibili crittazioni avrebbe qualche centinaio di zeri....
Quindi penso che sia difficile decrittarlo(anche se penso che ci sia un modo
alternativo al provare tutte le chiavi, se no per la sua semplicità tutti
l'avrebbero implementato: comunque non pretendevo di farla in barba alla
N.S.A :D.... Al massimo a un paio di pentium in parallelo.... :D)
Ciao
Steve

parti di codice giusto?
In teoria non dovrebbe, poi qulacuno potrebbe anche ettersi li con un
editor bin ma ci vorrebbe troppo tempo secondo me


 prova
Dunque:
File A :      111000101000111010
File B :      011010011101110001
Pad    :      111000100011100110
A xor Pad :   000000001011011100   chiamo questo AP
B xor Pad :   100010111110010111   chiamo questo BP
AP xor BP :   100010110101001011   #
A xor B   :   100010110101001011   #
Come vedi sono uguali... Quindi la pad bisogna usarla una sola volta,
altrimenti si perde MOLTO in sicurezza.




Hai ragione, avevo fatto amle i conti io
