Delphi - Szöveg titkosítása a Cézár-kód segítségével

forráskód letöltése
Ebben a cikkben az egyik legősibb titkosírásformát mutatjuk be, melyet már az ókori Rómában is használtak, köztük Julius Caesar is, akiről a nevét kapta. Ennek a kódolási formának a hatékonysága közel sem a legjobb, de az akkori időben megfelelt az elvárásoknak. Lényegében a későbbiekben használatos eltolt ABC-jű kódolási fajta egyik alapkövének tekinthető. Készítsünk hát egy olyan komponenst, ami nemcsak a Cézár-kód, hanem az eltolt ABC-jű kódolási formával is képes a szöveg titkosítására, ráadásul mindezt a magyar ABC-hez igazítva.
A mellékelt példaprogram megnyitása előtt a ShiftCode.pas-ban lévő komponenst telepítenie kell a Delphi alá. Ehhez válassza a Component - Install Component menüpontot.
Mielőtt azonban a programkód ismertetésébe belekezdenénk, ismerjük meg a Cézár-kód működési elvét. Vegyük az ABC betűit, és számozzuk meg sorban őket nullától kezdve a következő módon:
  • a: 0
  • á: 1
  • b: 2
  • c: 3
  • d: 4
  • e: 5
  • é: 6
  • f: 7
  • g: 8
  • h: 9
  • i: 10
  • í: 11
  • j: 12
  • k: 13
  • l: 14
  • m: 15
  • n: 16
  • o: 17
  • ó: 18
  • ö: 19
  • ő: 20
  • p: 21
  • q: 22
  • r: 23
  • s: 24
  • t: 25
  • u: 26
  • ú: 27
  • ü: 28
  • ű: 29
  • v: 30
  • w: 31
  • x: 32
  • y: 33
  • z: 34
Legyen a kódolandó szövegünk: animaresoftware
Helyettesítsük az egyes betűket a fenti felsorolás alapján a megfelelő számokkal.
  • a: 0
  • n: 16
  • i: 10
  • m: 15
  • a: 0
  • r: 23
  • e: 5
  • s: 24
  • o: 17
  • f: 7
  • t: 25
  • w: 31
  • a: 0
  • r: 23
  • e: 5
Legyen K az a szám, mellyel az ABC betűit el szeretnénk jobbra tolni. A Cézár-kód esetében ez a szám 3.
Adjuk a fenti felsorolás minden eleméhez egyenként a K értékét. Amennyiben a kapott összeg nagyobb vagy egyenlő az ABC betűinek számával, -mely esetünkben 35-, osszuk azt el az ABC betűinek számával, és eredményül vegyük az osztás maradékát. Ellenkező esetben az eredmény az eredeti összeg lesz. A következő felsorolás tartalmazza a kapott eredményeket.
  • a: 3
  • n: 19
  • i: 13
  • m: 18
  • a: 3
  • r: 26
  • e: 8
  • s: 27
  • o: 20
  • f: 10
  • t: 28
  • w: 34
  • a: 3
  • r: 26
  • e: 8
A kapott számoknak megfelelően visszaírjuk az ABC megfelelő betűit, és máris megkapjuk a kódolt szöveget.
  • 3: c
  • 19: ö
  • 13: k
  • 18: ó
  • 3: c
  • 26: u
  • 8: g
  • 27: ú
  • 20: ő
  • 10: i
  • 28: ü
  • 34: z
  • 3: c
  • 26: u
  • 8: g
A kapott kódolt szöveg a fentiek alapján: cökócugúőiüzcug
A Cézár-kód esetében a K értéke 3 volt. A későbbiekben használatos eltolt ABC-jű kódolási forma csak abban tér el a fenti ismertetett technikától, hogy a K értékét nagyobb számra választották, így jobb lett a kódolás hatékonysága. Azonban még ezzel sem lehetett elérni a megfelelő biztonságot, ugyanis ennek a fajta kódolásnak van egy nagy hibája. Mégpedig az, hogy az eredeti szöveg azonos betűinek a helyén a kódolt szövegben is azonos betűk fognak szerepelni. A mi példánkban is megfigyelhetjük mindezt.
  • a: c
  • n: ö
  • i: k
  • m: ó
  • a: c
  • r: u
  • e: g
  • s: ú
  • o: ő
  • f: i
  • t: ü
  • w: z
  • a: c
  • r: u
  • e: g
Láthatjuk, hogy az eredeti szövegben az „a” betű háromszor is szerepel, és a kódolt szövegben mindháromszor „c” betű helyettesíti. Így ha a kódolt szövegre elvégzünk bizonyos statisztikai számításokat, az eredeti szöveg viszonylag könnyen visszafejthető.
Most lássuk, hogy a komponensben mindezt hogyan valósítottuk meg. Létrehozunk egy Encode nevű függvényt, mely két paramétert vár értékül. Az egyik a kódolandó szöveg, a másik pedig K, azaz az eltolás értéke. Eredményül a kódolt szöveget adja vissza. Mielőtt a függvényt megvizsgáljuk, tudnunk kell, hogy a következő állandót illetve változókat deklaráltuk.
const
    ABC: string ='aábcdeéfghiíjklmnoóöőpqrstuúüűvwxyz';
var
    Nums: array[1..1000] of Integer;
    EncodedText: string;
Az ABC nevű állandóban eltároltuk az ABC betűit, melyeknek a sorszámait a Nums nevű integer típusú tömbben fogjuk eltárolni. Most lássuk a függvényt.
function TShiftCode.Encode(Text: string;k: integer): string;
var x,y,z,value: integer;
begin
  EncodedText:='';
  z:=0;
A Text változóban kapott szöveget karakterenként megvizsgáljuk az elejétől a végéig.
  for x:=1 to length(Text) do
  begin
Az y változóban eltároljuk, hogy az adott betű az ABC-ben hányadik helyen szerepel.
    y:=1;
    while ABC[y]<>Text[x] do
    begin
      inc(y);
    end;
A kapott értékből ki kell vonnunk 1-et, mivel az ABC számozása nullától kezdődik, azonban az ABC string karaktereinek számozása 1-től. Ezután hozzáadjuk a k változóban kapott értéket.
    value:=y-1+k;
Ha az összeg nagyobb vagy egyenlő 35-nél, azaz az ABC betűinek számával, akkor összeg mod 35 lesz az eredményünk.
    if value>=35 then value:=value mod 35;
A Nums tömbben egymás után eltároljuk a kapott értékeket.
    Nums[z]:=value;
    inc(z);
  end;
A kódolandó szöveg teljes hosszában elvégezzük a Nums tömbben tárolt számok visszaírását betűvé. A kapott betűket az EncodedText nevű string típusú változóban láncoljuk egymáshoz.
  for z:=0 to Length(Text)-1 do
  begin
    y:=Nums[z];
    EncodedText:=EncodedText+ABC[y+1];
  end;
A függvény visszatérési értékének az EncodedText-ben keletkezett karaktersorozatot adjuk.
  Result:=EncodedText;
end;
A mellékelt példaprogramban kipróbálhatjuk tetszőleges K értékkel a kódolás hatékonyságát. Ügyeljünk azonban arra, hogy a kódolandó szöveg nem tartalmazhat az ABC betűin kívül más karaktert (például pont, vessző, szóköz, stb…).