Newsgroup: it.comp.lang.visual-basic
Titolo: Nuovo algoritmo di crittazione!!! Algoritmo di Zuddas !!

In una notte insonne uno spiritello mi sussurrò codeste cose all'orecchio
:"Algoritmo di Zuddas...algoritmo di Zuddaaaas...." ed eccolo qua, di libero
uso personale non-profit. Lo presento al newsgroup magari qualcuno è
interessato.
Supponiamo di avere la frase:
cane mangia cane
ora associamo ad ogni lettera il numero che descrive la sua posizione
nell'alfabeto (26 lettere):
3-1-14-5  13-1-14-7-9-1  3-1-14-5
Qui inizia la codifica. Sommiamo un numero casuale al primo numero, ad
esempio 2 , quindi 3+2=5 :
5-1-14-5  13-1-14-7-9-1  3-1-14-5
Poi partendo dal secondo numero assegnamogli il valore dato dalla somma del
suo valore e del valore della posizione precedente, nel nostro caso 1+5=6 :
5-6-14-5  13-1-14-7-9-1  3-1-14-5
Poi una cosa analoga con il terzo numero, cioè 14+6=20 e così via...Se la
somma supera il numero di lettere disponibili (26) si sottrae 26 al
risultato ottenuto:
5-6-(14+6)-(5+(14+6))    (13+(5+14+6)-26)-((13+5+14+6-26)+1).....
Infine si ottiene:
5-6-20-25   12-13-1-8-17-18   21-22-10-15
che ritradotto in lettere:
e f t y    l m a h q r    u v j o
notate che la parola "cane" codificata non è uguale a se stessa. Ovviamente
converrebbe usare tutti i caratteri ascii, ed inoltre inserire questo tipo
di crittazione come aggiunta a procedimenti di crittazione già esistenti
così da aumenterne notevolmente la complessità.

 nell'alfabeto (26 lettere):
Ed i numeri?
[...]
Sto provando ad implementarlo, comunque. Sembra interessante!
CiaoZ
SebaMix

 e f t y    l m a h q r    u v j o
e per tornare all'origine? bisogna comunicare a parte al destinatario i
numeri casuali usati?

interessato.
Simpatico.
E' una versione generalizzata e resa ancora piu' simpatica del ROT13.
Praticamente, il ROT13 fa si' che tu aggiunga 13 alla lettera e che se
passi il 26, togli 26.
Il bello del ROT13 e' che basta applicarlo un'altra volta per ottenere
la stringa di partenza.
Infatti, ROT13 diventa EBG13 che diventa di nuovo ROT13.
Saluti che e' proprio carino.
-- 
      Gianni "bugbarbeq" Rondinini, 25, RA, 242, 152
  VBR - Vero Birro Romagnolo®, diffidate dalle imitazioni!
 Opel/ECC Calibrezio EVO-IV --- Kawasaki "Gas Gas" ZZ-R 1100
 ICQ# 36893168 - IRCNet: bugbarbeq, @ on #linux-it & #NetBSD

Ed i numeri?
Potremmo ragionare in termini di *36* e mettere le cifre in fondo alle
lettere. Praticamente, estendi l'alfabeto con le cifre, poi il resto
e' uguale.
Saluti.


Ecco qua le due funzioni: Zuddas e UnZuddas.
Funzionano con tutti i 256 caratteri della tabella ASCII, quindi non
dovrebbero esserci problemi. I test che ho fatto fino ad ora funzionano.
intKey č un numero > di 0.
strCrittata = Zuddas(strOriginale, Chiave)
strDecrittata = UnZuddas(strCrittata, Chiave)
Se la stringa originale č "1 cane mangia 1 cane"
la stringa crittata č "4T· ?ězŰJ± |oÍíQ˛!?"
La prossima versione la miglioro per evitare i caratteri di controllo.
Infatti nella stringa crittata potrebbero apparire caratteri mooolto strani
(come un a capo o altre cose del genere), che potrebbero rompere le uova nel
paniere.
CiaoZ!
Public Function UnZuddas(strInString As String, intKey As Integer)
    Dim PrimoPasso() As Integer
    Dim i As Integer
    Dim ch As String
    Dim NumberToAdd As Integer
    Dim NewNumber As Integer
    Dim strOutString As String
    strOutString = ""
    ReDim PrimoPasso(Len(strInString))
    For i = 1 To Len(strInString)
        ch = Mid(strInString, i, 1)
        PrimoPasso(i) = Asc(ch)
    Next i
    NumberToAdd = intKey
    ' DeCritto la stringa...
    For i = 1 To Len(strInString)
        ' Devo memorizzare prima il codice numerico...
        NewNumber = PrimoPasso(i)
        ' Decritto il carattere...
        PrimoPasso(i) = PrimoPasso(i) - NumberToAdd
        ' Se ottengo un numero < di 0...
        While Not PrimoPasso(i) >= 0
            ' Ci sommo 255 per ottenere il codice originale...
            PrimoPasso(i) = PrimoPasso(i) + 255
        Wend
        ' La nuova chiave...
        NumberToAdd = NewNumber
        ' Costruisco anche la stringa...
        strOutString = strOutString & Chr(PrimoPasso(i))
    Next i
    UnZuddas = strOutString
End Function
Public Function Zuddas(strInString As String, intKey As Integer) As String
    Dim PrimoPasso() As Integer
    Dim i As Integer
    Dim ch As String
    Dim NumberToAdd As Integer
    Dim strOutString As String
    strOutString = ""
    ' Passo 1
    ' Associo ad ogni carattere il suo valore ASCII.
    ReDim PrimoPasso(Len(strInString))
    'MsgBox Len(strInString)
    For i = 1 To Len(strInString)
        ' asc, chr
        ch = Mid(strInString, i, 1)
        PrimoPasso(i) = Asc(ch)
    Next i
    NumberToAdd = intKey
    ' Critto la stringa...
    For i = 1 To Len(strInString)
        PrimoPasso(i) = PrimoPasso(i) + NumberToAdd
        ' Se il numero č maggiore di 255...
        While Not PrimoPasso(i) <= 255
            ' Lo rendo codificabile in ASCII...
            PrimoPasso(i) = PrimoPasso(i) - 255
        Wend
        ' Calcolo la nuova chiave...
        NumberToAdd = PrimoPasso(i)
        ' Costruisco anche la stringa...
        strOutString = strOutString & Chr(PrimoPasso(i))
    Next i
    Zuddas = strOutString
End Function

 la stringa crittata č "4T· ?ězŰJ± |oÍíQ˛!?"
Dimenticavo: la chiave era 3. CiaoZ!

 wrote in message
95s1t7$2588$1...@stargate1.inet.it...


In effetti basta partire dal fondo e fare le operazioni inverse, poi per
risalire alla prima lettera serve il numero casuale.
Ad esempio lo spezzone:
r    u v j o
diventa
 18   21-22-10-15
poi dal fondo
(15-10)=5 -----> "e"
(10-22)=-12 che sommato a 26 da 14 -----> "n"
22-21=1------> "a"
21-18=3 -----> "c"
et voilà ricostruita la parola cane!
Randy <The_rea...@noshitYahoo.com> wrote in message
95rrd9$qcr$1...@fe1.cs.interbusiness.it...


 risalire alla prima lettera serve il numero casuale.
capisco. ma in questo modo non viene nascosto il msg ma solo la prima
lettera. su l'ultimo di neal stephenson (cryptonomicon) c'è un metodo sempre
a modulo 26 che utilizza mazzi da bridge. in teoria si può "comunicare" la
chiave al destinatario riferendosi a problemi di bridge pubblicati su
riviste di enigmistica pre-definite tra mittente/destinatario. per
complicare le cose occorrerebbe studiare un algoritmo in grado di utilizzare
chiavi pubbliche per generare blocchi monouso a radice pseudocasuale (per
esempio funzione di rienmann). il problema della crittografia imho consiste
nello studiare un metodo che regga alla forza bruta di un supercomputer per
un tempo tot, dove tot è il tempo minimo oltre il quale la segretezza non ha
più scopo di esistere. perchè non credo si possa affermare l'esistenza di un
sistema di crittografia "perenne", anche perchè è impossibile fare ipotesi
sullo sviluppo della tecnologia futura.

Certo, infatti questo metodo è esposto al suo livello base. Poi si può
affinare ed evolvere. L'interessante è che due parole uguali codificate non
sono più uguali, quindi addio brute force. Un sistema potrebbe essere quello
di eseguire la codifica una volta dalla cima e una dal fondo, oppure dalla
cima sclando di volta in volta di tot lettere. Comunque già dal primo
messaggio ho inteso l'utilizzo di questo sistema in abbinamento ad altri
algoritmi, in modo da aumentarne la complessità.
Ad esempio Zuddas+des+zuddas(inverso)+tripledes o cose simili. Non sono un
crittografo professionista, la mia era solo un' idea.
Randy <The_rea...@noshitYahoo.com> wrote in message
95s92e$r3f$1...@fe1.cs.interbusiness.it...


 algoritmi, in modo da aumentarne la complessità.
c'è il sorgente di pgp ma è in vc e non so se si possa riutilizzare
liberamente. ad ogni modo l'esigenza della privacy è sempre più sentita in
relazione a scarsa sicurezza sul lato net, specialmente per ciomp connessi a
internet. e non solo per quanto riguarda cosiddetti hackers, ma anche altri
soggetti più o meno "istituzionali". ben venga tutto quel che protegge i
dati.

Ho la stringa
"TOPOLINO"
La critto con chiave 100 e ottengo
"¸ X§ó=<Ú"
La decritto con chiave 32 (scelta a caso) e ottengo:
"~OPOLINO"
Solo la prima lettera è sicura.
Scusate!
--------
SebaMix

 wrote in message
960qh5$393i$1...@stargate1.inet.it...


Solo la prima lettera è sicura.
Settimana scorsa ho scritto questa semplice funzioncina di
criptaggio/decriptaggio per proteggere una password da sguardi indiscreti.
La funzione è auto-reversibile come l'algoritmo di Zuddas, ma serve la
chiave.
Comunque trovare la chiave è questione di un secondo :(
'{ Funzioni di criptaggio-decriptaggio }
'{ crypta un testo o lo decrypta se già criptato  }
'{ usa l'ultimo bit per indicare se text è        }
'{ criptato                                       }
'{ per stringhe con caratteri che non superano il }
'{ chr$(127) setta l'8° bit per indicare che è il }
'{ carattere è stato criptato                     }
Function Encrypt(text As String, Key As Byte) As String
  Dim i As Integer
  Dim key_for_char As Integer
  Encrypt = vbNullString
  For i = 1 To Len(text)
    key_for_char = (Key + i) Mod 128 '{ generiamo un po' di casino }
    Encrypt = Encrypt + Chr$((Asc(Mid$(text, i, 1)) Xor key_for_char) Xor
128)
  Next i
End Function
Un semplice modo per creare una chiave automaticamente da prog. può essere
questo:
'{ ritorna una chiave univoca sia dato il testo }
'{ che il testo criptato                        }
'{ Il testo da criptare con questa chiave non   }
'{ può però superare i 127 caratteri  (credo)   }
Function GetKey(text As String) As Long
  GetKey = Len(text) Mod 128
  If (GetKey = 0) Then result = &HAB
End Function
Ciao