Binaire encryptie

Encryptie is een manier om data onleesbaar te maken voor mensen. Dit gebruik je als je data wilt beveiligen tegen ongewenste aanpassingen. Je versleutelt de bestanden en kunt ze daarna ontsleutelen om de originele data terug te krijgen. Het idee is dat je die data alleen kan lezen als je de sleutel hebt.

Binaire encryptie is een eenvoudige vorm van versleuteling, geschikt om het principe uit te leggen.

Het idee

Als je twee waarheidswaarden hebt, A en B, dan kun je spreken over

A and B. Dit is waar als A en B beide waar zijn.
A or B. Dit is waar als A of B waar is (of allebei).

or en and zijn twee logische operatoren. Er is nog een derde:

A xor B. Dit is waar als A of B waar is, maar niet als A en B beide waar zijn.

Oftewel:

false xor false = false
false xor true = true
true xor false = true
true xor true = false

Deze operator noemen we exclusive or, of kortweg xor.

Dezelfde functie bestaat ook op bits, en dan noemen we hem bitwise xor en we gebruiken het symbool ^:

0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0

Alle data bestaat uit bits. Dus een functie die werkt op bits, kun je laten werken op alle data. Bijvoorbeeld, op getallen. Dus: wat is 123 ^ 456? Wel, bekijk het per bit.

				123:  001111011
				456:  111001000
				-----------------xor
				      110110011:  435.

Dus 123 ^ 456 = 435. De operator xor is toegepast op overeenkomstige bits uit 123 en 456.

Omkeerbaarheid

Je kent vast het principe van een “invulsom”. Het leuke van een invulsom is dat je 'm berekent met de omgekeerde bewerking:

12 + ... = 57 → je berekent 57 − 12 = 45 → 12 + 45 = 57.
... ÷ 5 = 12 → je berekent 12 × 5 = 60 → 60 ÷ 5 = 12.

Ook met or kun je invulsommen maken. Alleen is er iets eigenaardigs aan de hand:

true or ... == true → true en false zijn allebei oplossingen
true or ... == false → er zijn geen oplossingen.

Invulsommen met xor hebben dit probleem niet: dan is er altijd precies één antwoord: En dat antwoord bereken je... met xor. Oftewel: de omgekeerde bewerking van xor is xor zelf.

Willekeur

Stel, B is willekeurig. Er is 50% kans dat B = 1, en 50% kans dat B = 0. Wat is A ^ B?

Stel A = 1. Dan is er

50% kans dat A ^ B = 1 ^ 1 = 0.
50% kans dat A ^ B = 1 ^ 0 = 1.

Stel A = 0. Dan is er

50% kans dat A ^ B = 0 ^ 1 = 1.
50% kans dat A ^ B = 0 ^ 0 = 0.

Oftewel, A ^ B is altijd met 50% kans 1 en met 50% kans 0. Ongeacht wat A is. Oftewel, als B willekeurig is, is A ^ B ook willekeurig. Als we dus niets weten over B, dan kunnen we dus uit A ^ B ook niets over A te weten komen - want we weten zeker dat A ^ B willekeurig is en ons dus niets vertelt!

Maar (A ^ B) ^ B is hoe dan ook A.

De toepassing op encryptie

Goed. Wat we kunnen doen met bits, kunnen we doen met bitstrings, maar per bit (vandaar bitwise). Dus A wordt een bitstring, en B wordt een willekeurige bitstring: elke bit is met 50% kans 1 en met 50% kans 0. Bereken C = A ^ B. Vanwege bovenstaand is C willekeurig. Dus uit C is geen informatie af te leiden over A. Maar C ^ B is wel weer gewoon A.

Nu is A onze data. En B is onze sleutel. We houden B geheim. Dus voor een buitenstaander kan B alles zijn — B is willekeurig. We berekenen C = A ^ B en slaan dit op. Mensen kunnen C nu bekijken. Maar uit C is geen informatie af te leiden over A zolang we niets weten over B!

Comprimeren

In chaos zit geen regelmaat. En comprimeren werkt op basis van patronen. Dus chaos kun je niet comprimeren. Echter hebben we liever niet dat onze sleutel B heel groot wordt. We zullen dus moeten comprimeren. We moeten dus een patroon toevoegen aan B. Hierdoor is echter B niet meer chaotisch, waardoor we niet meer alle informatie uit A verbergen. Maar gelukkig nog wel het meeste.

We kiezen ervoor om van B een herhaling maken van 8n bits oftewel n bytes waarbij n klein is. We kunnen B dan opslaan in n bytes; die we bij het versleutelen steeds herhalen.

Het script

Een encryptieschema heeft altijd twee functies nodig: encryptie (vercijfering) en decryptie (ontcijfering). Bij onze binaire encryptie is het vercijferen “xor B doen”. Maar ontcijferen is óók “xor B doen”! We hebben dus maar één script nodig! Hier komt ’ie:

1
2
3
4
5
6
7
8
9
10
11
12

///string_binary_encrypt(str)
var s1 = string_length(argument0);
var answer = "";
var kb = 1;
for (var t = 1; t <= s1; t += 1) {
    var b1 = ord(string_char_at(s1, t);
    var k1 = keybyte[kb];
    kb += 1; if kb > keysize {kb = 1;} //find next byte in key
    var b2 = b1 ^ k1;
    answer += chr(b2);
}
return answer;

Dit script versleutelt een string str. Omdat de omgekeerde bewerking van ^ de bewerking ^ zelf is, is het ontsleutelingsscript exact hetzelfde. Je hebt dus maar één script nodig.

De sleutel heeft lengte keysize bestaat uit de bytes keybyte[1] tot en met keybyte[keysize]. Elke keybyte is een geheel getal van 0 tot en met 255 en elk teken van str ook.

Het idee is dat de keybytes moeilijk te raden zijn, en dat de keysize groot genoeg is. Wat is groot genoeg? Voor hele simpele toepassingen is 10 bytes al genoeg, maar 100 bytes is natuurlijk beter. Het hangt ook af van je data. Tot slot is uiteraard iets als "?&úî~7" een betere sleutel dan "geheim".