Un algoritmo è un insieme di istruzioni che si devono eseguire per agire su uno o più dati al fine di modificarli in un certo modo. In questo tutorial mi occuperò di algoritmi che modifichino strighe e caratteri. Infatti gli algoritmi di criptazione hanno il compito di rendere indecifrabili dati e stringhe a chi non possieda la chiave o il modo di decifrarli.
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