Ho suddiviso gli algoritmi che conosco in 5 tipi (non prendete i nomi per ufficiali, ché non lo sono, ma aiutano ad identificare bene le differenze).
1-ALGORITMI DI MODIFICA SINGOLA DEI CARATTERI:
Agiscono su un carattere alla volta, eseguendo sempre la stessa operazione. Ci sono due esemplari di questi algoritmi: il primo, il più semplice, consiste nell'assegnare ad un carattere un altro carattere scelto da noi, magari utilizzando due array delle stesse dimensioni (un array di x elementi che contiene il carattere da criptare ed un secondo array di x elementi che contiene il corrispettivo criptato del carattere); il secondo, più diverso, consiste nell'eseguire operazioni aritmetiche sul codice ASCII del carattere e restituire un numero diverso che sarà il codice ASCII del carattere criptato. Il primo è molto facile da craccare, poichè esistono delle figure, i crittanalisti, che, usando una tabella delle frequenze, riescono a capire a quale lettera corrisponda quale altra lettera semplicamente contando quante volte un determinato carattere ricorre. Infatti ogni lingua ha una lettera che è usata di più, una di meno, e diversi altri gradi della scala: in inglese, per esempio, la lettera più frequente è la 'E'. Per il secondo vale lo stesso discorso, ma con un numero inferiore di conversioni, invece, si può scoprire l'operazione che lega il carattere inziale con quello criptato e scrivere un programma che decripti tutto.
Un piccolo esempio del secondo:
Public Function Cripta(c As Char) As Char Return chr(255-asc(c)) End Function Public Function Decripta(c As Char) As Char) Return Cripta(c) End Function
2-ALGORITMI DI MODIFICA MULTIPLA DEI CARATTERI:
Si differenziano dagli altri perchè invece di eseguire operazioni sempre uguali e ripetitive sul carattere considerandone le intrinseche proprietà, si basano, al contrario, sulle proprietà della stringa a cui il carattere appartiene. Un buon esempio è rappresentato dalle due seguenti funzioni, che aggiungono al codice ASCII di ogni carattere l'ultima cifra del numero che indica la posizione del carattere nella stringa (ovviamente solo nel caso in cui la loro somma sia minore di 255):
Public Function cripta(s As String) As String Dim i As int64 Dim cifra As int16 For i=0 To s.Length-1 'Converte l'indice i in una stringa e ne estrapola il carattere finale 'che corrisponde all'ultima cifra dell'indice stesso cifra=Val(CType(i,String).chars(CType(i,String).Length-1)) 'Se la somma fra il codice ASCII del carattere numero i e la variabile cifra è minore di 255... If asc(s.chars(i))+cifra<255 Then cripta=cripta & chr(asc(s.chars(i))+cifra) Else cripta=cripta & chr(asc(s.chars(i))-cifra) End If Next End Function Public Function decripta(s As String) As String Dim i As int64 Dim cifra As int16 For i=0 To s.Length-1 'Converte l'indice i in una stringa e ne estrapola il carattere finale 'che corrisponde all'ultima cifra dell'indice stesso cifra=Val(CType(i,String).chars(CType(i,String).Length-1)) 'Se la somma fra il codice ASCII del carattere numero i e la variabile cifra è minore di 255... If asc(s.chars(i))-cifra<0 Then decripta=decripta & chr(asc(s.chars(i))+cifra) Else decripta=decripta & chr(asc(s.chars(i))-cifra) End If Next End Function
3-ALGORITMI A CHIAVE NUMERICA:
Prima di eseguire il rocesso di criptazione viene richiesta l'immissione di un numero, che sarà la chiave con cui criptare i caratteri. Il procedimento è molto semplice: si agisce modificando con operazioni aritmetiche (di solito la moltiplicazione) il codice ASCII del carattere e si ha come output un numero. Spessissimo si usa la moltiplicazione e si fa leva sulla difficoltà di fattorizzare i numeri colto grandi. Un piccolo esempio:
Public Function Cripta(c As Char,key As int16) As int32 return asc(c)*key End Function Public Function Decripta(num As int32, key As int16) As int16 return num/key End Function
4-ALGORITMI A CHIAVE STRINGA:
Come nel caso precedente, si moltiplica il codice ASCII del carattere per la chiave. Ma la chiave è una stringa, quindi dobbiamo trovare il modo di farla diventare un intero. Il più delle volte si sommano i codici ASCII dei singoli caratteri, ma nessuno vieta di eseguire operazioni molto più complesse per rendere più sicuro l'algoritmo (per esempio una moltiplicazione fra i primi due, il cui prodotto viene sommato al codice ASCII negativo del successivo, cose del genere). Il problema con questi algoritmi è che se si usa solo la somma oppure il prodotto, si può incorrere in errori come OverflowErrorException. Ecco perchè è bene manipolare la stringa in modo da far risultare piccola la chiave. Esempio:
Public Function ToIntK(s As String) As int32 Dim i As int32 For i=0 to Len(s)-1 if i mod 2=0 Then ToIntk+=asc(s.chars(i)) Else ToIntK-=asc(s.chars(i)) End If Next Return Abs(ToIntK) End Function Public Function Cripta(c As Char,key As String) As int64 Return asc(c)*ToIntK(key) End Function Public Fuction Decripta(c As Int64,key As String) As Char return chr(c/ToIntK(key)) End Function
5-ALGORITMI COMPOSTI:
L'utilizzo degli algoritmi precedenti in un unico algoritmo aumenta notevolmente la sicurezza dell'algoritmo, essendo quest'ultimo, non lineare, ma composito, frutto dell'uso di più operazioni. Un esempio di algoritmo di modifica singola e multipla dei caratteri:
Public Function cripta(s As String) As String Dim i As int64 Dim cifra As int16 For i=0 To s.Length-1 'Converte l'indice i in una stringa e ne estrapola il carattere finale 'che corrisponde all'ultima cifra dell'indice stesso cifra=Val(CType(i,String).chars(CType(i,String).Length-1)) 'Se la somma fra il codice ASCII del carattere numero i e la variabile cifra è minore di 255... If 255-asc(s.chars(i))+cifra<255 Then cripta=cripta & chr(255-asc(s.chars(i))+cifra) Else cripta=cripta & chr(255-asc(s.chars(i))-cifra) End If Next End Function Public Function decripta(s As String) As String Dim i As int64 Dim cifra As int16 For i=0 To s.Length-1 'Converte l'indice i in una stringa e ne estrapola il carattere finale 'che corrisponde all'ultima cifra dell'indice stesso cifra=Val(CType(i,String).chars(CType(i,String).Length-1)) 'Se la somma fra il codice ASCII del carattere numero i e la variabile cifra è minore di 255... If 255-asc(s.chars(i))-cifra<0 Then decripta=decripta & chr(255-asc(s.chars(i))+cifra) Else decripta=decripta & chr(255-asc(s.chars(i))-cifra) End If Next End Function
Aggiungi un commento