Het Vernam Cipher/cijfer (ook wel het “One-Time-Pad”) genoemd is het éénmalig blokcipher of het perfecte cipher genoemd, is een crypto algoritme waarbij men de tekst of data combineert met een willekeurige Sleutel/Key van dezelfde lengte. Het is de enige gekende vercijfering die onbreekbaar is.

Gebruikt door Special Operations teams en het verzet in Wereldoorlog II, populair bij inlichtingendiensten en hun spionnen sinds de Koude Oorlog en decennialang ten dienste van de diplomatie en het leger heeft het Vernam Cipher een sterke reputatie opgebouwd als eenvoudige maar onbreekbare encryptie met een absolute veiligheid die ongeëvenaard is door moderne crypto algoritmes.

Om van Vernam Cipher encryptie te kunnen spreken en de onbreekbaarheid effectief te verwezenlijken dient aan verschillende voorwaarden voldaan te zijn. Indien één van deze voorwaarden ontbreekt kan men niet meer spreken van het Vernam Cipher/One-Time-Pad en is het niet meer onbreekbaar. Bij correct gebruik is Vernam Cipher/One-Time-Pad echter de enige bestaande bewezen perfect veilige vercijfering, bestand tegen elke mogelijke cryptoanalytische aanval. Dit werd bewezen in Claude Shannon’s verhandeling ‘Communication theory of secrecy systems’.

De criteria voor een echte Vernam Cipher:
– De sleutel moet op een volstrekt willekeurige manier zijn gegenereerd.
– De sleutel moet dezelfde lengte als de platte tekst hebben.
– De sleutel mag slechts één keer gebruikt worden.
– Na één keer gebruik moet de sleutel vernietigd worden.
– Van een sleutel mogen slechts twee kopieën bestaan, een voor de verzender en een voor de ontvanger van de gegevens.

Door aan deze criteria te voldoen, wordt de resulterende versleutelde tekst statistisch, willekeurig en theoretisch onkraakbaar. Hierdoor is frequentieanalyse onmogelijk en is ontcijfering onmogelijk zonder de juiste sleutel.

De Code is ONKRAAKBAAR omdat het berust op een willekeurig gegenereerd getal. Zelfs met de allergrootste huidige supercomputers is de code niet te kraken MITS alle voorwaarden correct worden nageleefd.

In [B1] zet je de plaintext. Als voorbeeld hebben we de volgende tekst gebruikt:
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
In [B2] =GenerateKey(LEN(B1))
In [B3] =EncryptTextUDF(B1; B2)
In [B4] =DecryptTextUDF(B3;B2)

En dan de VBA code:

Option Explicit

' =========================================================
'   Vernam Cipher (XOR-based) with Hex Encoding for Excel
' =========================================================

' Generate a random key of the same length as the plaintext (A–Z)
Function GenerateKey(plaintextLength As Long) As String
    Dim i As Long
    Dim key As String
    Randomize
    For i = 1 To plaintextLength
        key = key & Chr(Int(Rnd * 26) + 65)
    Next i
    GenerateKey = key
End Function

' Encrypt plaintext using XOR, return readable hex string
Function EncryptText(plaintext As String, key As String) As String
    Dim i As Long
    Dim pChar As Integer, kChar As Integer, cChar As Integer
    Dim cipherHex As String

    If Len(key) < Len(plaintext) Then
        EncryptText = "#KEY TOO SHORT#"
        Exit Function
    End If

    For i = 1 To Len(plaintext)
        pChar = Asc(Mid(plaintext, i, 1))
        kChar = Asc(Mid(key, i, 1))
        cChar = pChar Xor kChar
        cipherHex = cipherHex & Right("0" & Hex(cChar), 2)
    Next i

    EncryptText = cipherHex
End Function

' Convert hex string to raw binary string
Private Function HexToString(hexStr As String) As String
    Dim i As Long
    Dim result As String
    Dim val As Long

    hexStr = Replace(hexStr, " ", "")
    If Len(hexStr) Mod 2 <> 0 Then
        HexToString = ""
        Exit Function
    End If

    For i = 1 To Len(hexStr) Step 2
        val = CLng("&H" & Mid(hexStr, i, 2))
        result = result & Chr(val)
    Next i

    HexToString = result
End Function

' Decrypt hex ciphertext using XOR with key
Function DecryptText(cipherHex As String, key As String) As String
    Dim i As Long
    Dim plaintext As String
    Dim cChar As Integer, kChar As Integer, pChar As Integer
    Dim cipherRaw As String

    cipherRaw = HexToString(cipherHex)

    If Len(key) < Len(cipherRaw) Then
        DecryptText = "#KEY TOO SHORT#"
        Exit Function
    End If

    For i = 1 To Len(cipherRaw)
        cChar = Asc(Mid(cipherRaw, i, 1))
        kChar = Asc(Mid(key, i, 1))
        pChar = cChar Xor kChar
        plaintext = plaintext & Chr(pChar)
    Next i

    DecryptText = plaintext
End Function

' =========================================================
'   Worksheet-Friendly UDFs
' =========================================================

' Manual key versions (for static use)
Function EncryptTextUDF(plaintext As String, key As String) As String
    EncryptTextUDF = EncryptText(plaintext, key)
End Function

Function DecryptTextUDF(cipherHex As String, key As String) As String
    DecryptTextUDF = DecryptText(cipherHex, key)
End Function

' =========================================================
'   Auto-Key Paired Functions (for use in adjacent cells)
' =========================================================



' Generates and stores a random key (updates each recalc)
Function EncryptAutoKey_Key(plaintext As String) As String
Dim gAutoKey As String
    gAutoKey = GenerateKey(Len(plaintext))
    EncryptAutoKey_Key = gAutoKey
End Function

' Uses the most recently generated key for the same recalc cycle
Function EncryptAutoKey_Cipher(plaintext As String) As String
Dim gAutoKey As String
    If gAutoKey = "" Then
        ' fallback: if used standalone, generate a key automatically
        gAutoKey = GenerateKey(Len(plaintext))
    End If
    EncryptAutoKey_Cipher = EncryptText(plaintext, gAutoKey)
End Function

' =========================================================
'   Quick Test (Immediate Window)
' =========================================================
Sub TestVernamCipher()
    Dim plaintext As String, key As String, cipherHex As String, decrypted As String
    plaintext = "HELLO"
    key = GenerateKey(Len(plaintext))
    Debug.Print "Plaintext: " & plaintext
    Debug.Print "Key: " & key
    cipherHex = EncryptText(plaintext, key)
    Debug.Print "Ciphertext (Hex): " & cipherHex
    decrypted = DecryptText(cipherHex, key)
    Debug.Print "Decrypted Text: " & decrypted
End Sub

Je kunt de code vanuit de VBA IDE bereiken via sneltoets Alt-F11 en dan Sub TestVernamCipher starten middels F5.

Belangrijk: Je kunt het beste geen computer gebruiken om de Key/Sleutel voor een Vernam Cipher te genereren, omdat een door de computer gegenereerde Key niet echt willekeurige cijfers of letters kan genereren. waardoor deze kwetsbaar is voor cryptoanalyse
Om de perfecte geheimhouding van het Vernam Cipher te bereiken, moet de sleutel echt willekeurig zijn, dezelfde lengte hebben als het bericht, slechts één keer worden gebruikt en veilig worden gedeeld tussen de verzender en de ontvanger.

Een computer maakt doorgaans gebruik van PRNG, een deterministisch algoritme dat een reeks getallen produceert die willekeurig lijkt, maar in werkelijkheid voorspelbaar is als de beginwaarde 
en het algoritme bekend zijn.