Newsgroup: it.comp.lang.c
Titolo: Crittografia

Ho fatto un programma di crittografia che rielabora il discorso trito e
ritrito dello xor del testo in chiaro con una chiave implementando un
elementarissimo generatore di numeri casuali... Il seed varia da 0 a 888886
e ho verificato che tutti i numeri in quel range, dopo aver definito il seme
iniziale(il seed appunto) vengono coperti...
Il programma è il seguente:
............................................................................
................................
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char password[50];
char stringa[2];
long seed=0;
long casual;
long multiplier;
long addition;
long i=0;
char leggi;
long file;
long modulo;
int p=0;
int p2=0;
FILE *fp;
FILE *fp2;
main(int argc, char *argv[])
{
if(argc<2)
{
 fprintf(stderr,"\nSintassi: critta nomefile.xxx...\n");
 exit(0);
}
modulo=888887;
strcpy(stringa,"nsa");
fp=fopen(argv[1],"rb");
if(fp==NULL)
{
fprintf(stderr,"\nErrore in apertura file origine...\n");
exit(1);
}
fp2=fopen("xyzk.xyzk","wb");
if(fp2==NULL)
{
 fprintf(stderr,"\nDisco protetto da scrittura o errore in scrittura
file...\n");
 exit(1);
}
fseek(fp,0,SEEK_END);
file=ftell(fp);
rewind(fp);
printf("Password: ");
scanf("%s",password);
p=strlen(password);
if(argc>2)
{
if(strcmp(argv[2],stringa)==0)
 {
 printf("\nInserisci un numero tra 0 e 888886: ");
 scanf("%d",&seed);
 }
}
else
{
while(p2!=p)
 {
 seed=seed+password[p2++];
 }
}
seed=seed%modulo;
p2=0;
multiplier=18773;
addition=666667;
while(!(i==file))
{
leggi=fgetc(fp);
casual=(((multiplier*seed)+addition)%modulo);
seed=casual;
if (p2==p)
 p2=0;
casual=casual^password[p2];
leggi=leggi^casual;
fwrite(&leggi,sizeof(leggi),1,fp2);
i++;
p2++;
}
fclose(fp);
fclose(fp2);
remove(argv[1]);
rename("xyzk.xyzk",argv[1]);
return 0;
}
............................................................................
......................
Esistono attacchi crittanalitici ad un programma di questo genere?(se sì mi
potreste dire dove trovarli?)...
Pensate che per una sicurezza di tipo casalingo un programma di questo
genere sia sufficente?(per intenderci: è craccabile nel giro di qualche
minuto, ora , secondo o può tenere per diciamo almeno un mese?)
Ovviamente so benissimo  di non poter competere con Triple Des o
IDEA(hehehe) ma le mie limitatissime conoscenze matematiche e informatiche
al momento mi permettono solo questo...
Al massimo qualcuno mi saprebbe dire dove potrei trovare un buon tutorial
(in italiano) che spieghi per esempio come funzioni il sistema IDEA e le sue
implementazioni(sul sito del dsi di milano ho visto che c'era un corso
riguardo la crittografia ma non ho trovato nient'altro che il programma...)
Grazie
Stefano

 strcpy(stringa,"nsa");
mmm....
-- 
 Ciao, Bianco.
 Reply to luca.bianco (at) 
tiscalinet.it

 mmm....
Si vabbè forse non era il nome + adatto da dare ad un parametro :-D
Comunque sai se  sono possibili tecniche di crittanalisi su questo tipo di
algoritmi?

 algoritmi?
Mi dispiace, ma non sono ferrato in materia di sicurezza...


 No, non hai capito... la tua variabile stringa e' un array di 3 char,
Veramente è di due caratteri.
EMG

partendo da 
www.ascom.ch
  (che detengono il brevetto internazionale
di IDEA) si arriva a:
http://www.media-crypt.com/pages/fidea.html
dove tutto l' algoritmo e' descritto in una chiarissima gif.
Si evidenzia come sia ben disegnato!! Descrizioni in italiano
non sono necessarie.
Altri algoritmi interessanti sono blowfish e twofish, NO PATENTED
e disponibili a 
www.counterpane.com
Non sono un crittoanalista, ma facendi considerazioni sugli
algoritmi su citati, mi sembra di capire che il proposito di tutti
i progettisti sia quello di avere proprieta' dette "orizzontali",
come per l' hash o il CRC, cioe' si cerca di produrre testi
cifrati i cui bits in ogni posizione dipendono da tutti i bits
della chiave E ANCHE DAGLI ALTRI BITS DEL TESTO IN CHIARO!!
Algoritmi cosi' sono resistenti anche ad attacchi basati su 
dizionario di parole frequenti, inoltre, proprieta' molto 
importante, e' molto difficile ottenere la chiave anche disponendo
del testo in chiaro e del testo cifrato. Lo xor non ha nessuna
di queste proprieta': nel tuo esempio e' molto furbo il fatto che
anziche' usare la chiave direttamente, la usi per ricavarne una
pseudocasuale (anche se a questo punto il seed diventa esso stesso
un crittovariabile, quindi parte della chiave), tuttavia conoscendo
una piccola porzione di testo, facendo lo xor (che notoriamente
ha proprieta' associativa con se stesso e se stesso come operaz.
inversa) si ottiene non la chiave, ma una comunque utilizzabile
per decrittare il resto del testo. Ad un attacco analitico credo
possa essere resistente, ma non ad uno euristico (ma ti ripeto:
NON SONO UN ESPERTO). ti suggerisco di corredare di corredare
l' algoritmo di proprieta' orizzontali. Studiare IDEA e BLOWFISH
e' illuminante. Un suggerimento che viene da IDEA:
(non venire pero' a chiedere a me l' applicaz. di test
crittoanalistici, non ho le basi matematiche)
Il concetto di round e' fondamentale e questo limita' la lunghezza
della chiave, altrimenti i round diventano troppi e bisogna
operare con registri grandi (idea ida 16 bits di registro e 8 round)
ti selezioni 2 o 3 operazioni di tre gruppi algebrici diversi
(definizione da documenti di IDEA) che operano su  due registri
e che siano reversibili
una potrebbe essere lo XOR tra due registri, l' altra la somma
modulo 2 pow 16 (per troncare overflow), una potrebbe anche essere
l' accesso ad una tabella mappata con valori unici.
ad ogni round di chiave puoi:
operazioni:
xor, 
op1 = somma froncata a overflow
op2 accesso a tabella associativa
per op1 e op2 vanno poi definite operazioni inverse
|-----a-----|-----b-----|-----c-----|----d------|
|----k0-----|----k1-----|----k2-----|----k3-----|
|-a xor b---|-b op1 k1--|-c xor k2--|-d op1 k3--|
|-op2 con k0|           |-op2 con k2|
round successivo con shift chiave per quanti round vuoi.
ATTENZIONE: nessuno inventa un algoritmo in 2 minuti, questo
serve solo ad avere una idea dell' "orizzontalita'".
Vedi che ad ogni passo devi decrittare un blocco per avere
la chiave per decrittare il blocco adiacente ed essendo le
operazioni scelte di gruppi algebrici diversi no e' facile
(per me) ricavare proprieta' distributive o associative tra
le operazioni.
Se vuoi continuare la conversazione usiamo la posta.
P.S. la parte di codice che genera un numero pseudo random
e' buona? la posso usare? I valori delle costanti come li hai
scelti?
ciao.
Roberto.

 variabile.
Strano, mi funziona ugualmente... Comunque hai ragione...

 Veramente è di due caratteri.
Si', hai ragione... lo studio mi sta rovinando ;-)


Strano, mi funziona ugualmente... Comunque hai ragione...
Molto dipende dal significato che assegni al termine "funziona".
Io direi che "con quel sistema operativo e quel compilatore
di quella versione, quella volta non e' esploso il monitor
quando ho lanciato il programma".
Con "funziona" intendo qualcos'altro.
Scherzi a parte non e' un problema da poco. E' questione di
atteggiamento mentale che secondo me con linguaggi come il C
e' necessario avere. Quel programma non ha mai "funzionato";
semplicemente non hai visto i danni, cosa che capita purtroppo
spessissimo.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 spessissimo.
Ok cercherò di acquisire una + corretta forma mentis....
:-D