Vektor Verschlüsselung

Table of Contents

1. Schlüsselgenerierung
2. Schlüsselausgabe
3. Verschlüsselung
4. Entschlüsselung
5. Abschließende Worte

Einleitung

In diesem Artikel beschäftigen wir uns einer "selbst erstellen" Verschlüsselung. Der Code wurde ursprünglich in Python 3.8.10 programmiert, doch in Zukunft soll der Code in die Programmiersprachen C und C++ übertragen werden. Da es sich um eine symmetrische Verschlüsselung handelt, dessen Rechenaufwand nicht wirklich anspruchsvoll ist, darf diese Art eine Nachricht zu verschlüsseln nicht als sicher angesehen werden. Es handelt sich hierbei um eine Erweiterung der Caesar-Verschlüsselung, die ebenfalls in der heutigen Zeit nicht mit sicher in Verbindung gebracht wird.

Python-Code: github/Pulsar7/A.M.M.E

Schlüsselgenerierung

Zum Erstellen eines Schlüssels werden vier Vektoren je Zeichen - das von der Verschlüsselung akzeptiert werden soll - generiert. Dabei wird in meinem Python-Code das Modul random benutzt. Der Sinn dahinter ist, dass diese Vektoren zwei Geradengleichungen pro Zeichen bilden sollen.

elements = [
    'd_v_1',
    's_v_1',
    's_v_2',
    'd_v_2'
]
while True:
    vectors = {}
    for element in elements:
        vectors[element] = (random.randint(self.min_num,self.max_num),random.randint(self.min_num,self.max_num))
    t = sympy.symbols("t") # creating symbols for the equation
    solution_1 = sympy.solve(sympy.Eq((vectors['d_v_1'][0]*t),(vectors['d_v_2'][0])),t)
    solution_2 = sympy.solve(sympy.Eq((vectors['d_v_1'][1]*t),(vectors['d_v_2'][1])),t)
    if (solution_1 != solution_2):
        break

• d_v_1: Richtungsvektor 1
• d_v_2: Richtungsvektor 2

Wurden nun alle Zeichen erfolgreich zwei Geradengleichungen zugewiesen, müssen noch die Schnittwinkel berechnet werden. Zuerst wird das Skalarprodukt der beiden Vektoren berechnet:

s = (vectors['d_v_1'][0]*vectors['d_v_2'][0]+vectors['d_v_1'][1]*vectors['d_v_2'][1])

Danach müssen noch die Längen der beiden Vektoren multipliziert werden:

one = ((vectors['d_v_1'][0])**2+(vectors['d_v_1'][1])**2)
two = ((vectors['d_v_2'][0])**2+(vectors['d_v_2'][1])**2)
p = ((math.sqrt(one))*(math.sqrt(two)))

Nun muss noch der Arkuskosinus des Bruchs berechnet werden:

a_rad = math.acos((s)/(p)) # in RAD
a_deg = (a_rad*(360/(2*math.pi))) # in DEGREE
a_deg = round(a_deg,15)
angle = a_deg

In diesem Code-Abschnitt wird der berechnete Winkel auf 15 Nachkommastellen gerundet. In einer späteren Version wurde eine weitere Funktion FAST-Mode hinzugefügt, die dessen Nachkommastellen auf fünf reduziert.

Hier sind mehr Informationen über die Formel, die in diesem Script verwendet wurde: Serlo / Winkel zwischen Vektoren

Schlüsselausgabe

Um die Berechnungen hinter dieser Verschlüsselung zu "verschleiern", werden die Nachkommastellen des Winkel verschoben und noch paar weitere Zeichen zur Verwirrung hinzugefügt:

if ("." in str(angle)):
    args = str(angle).split(".")
    this_angle = "".join(args)+str(len(args[0]))
else:
    this_angle = angle

Beispiel:

angle = 14.555553656745373
if ("." in str(angle)):
    args = str(angle).split(".")
    this_angle = "".join(args)+str(len(args[0]))

>>> '145555536567453722'

Später im Code werden zusätzlich noch Elemente hinzugefügt:

for element in self.calculated:
    key = key+element+":*"+self.calculated[element]['angle']+"x."

Der Schlüssel kann beispielsweise so aussehen:

a:*33851544063138082x.b:*29271285021598432x.c:*182644011355389642x.d:*13357347084340931x.e
:*382801771841068262x.f:
*92346239469598061x.g:*30864129672729642x.h:*35084831329657742x.i:*19175451913270371x.j:
*276692732656086772x.k:*29715896729243051x.l:*84014365621161121x.m:*613719389690902942x.n:
*40055943797743762x.o:*11505581282645772x.p:*472017218173351842x.q:*52556985957810172x.r:
*186152368657472172x.s:*187859678157643552x.t:*285667351599327442x.u:*498428449009644442x.
v:*381876699240950762x.w:*67113915655690532x.x:*186125424137355322x.y:
*42204947851898022x.z:*20326005466374091x.A:*10438898275136772x.B:*36636778671998862x.C:
*612676232153333442x.D:*156813260762321042x.E:*32379655862850422x.F:*77420307952971382x.G:
*34626162235091971x.H:*55359141051275062x.I:*44330834060452632x.J:*664537529725072x.K:
*32251849704652992x.L:*63947150398092982x.M:*40121557672680412x.N:*67419425033490712x.O:
*30896984085347661x.P:*209240676629659672x.Q:*1824866450053371x.R:*46027181095563962x.S:*
37980772096072682x.T:*92631626643912221x.U:*99633158373760781x.V:*38593772128033512x.W:*
41320054079386511x.X:*07267570812080041x.Y:*24866289278206162x.Z:*60375523601015822x.!:
*473914631054005262x.":*249320216564553942x.#:*57056362183783592x.$:*150799136266083862x.
%:*55898235347656072x.&:*468288039932338052x.':*51518447473246292x.(:*421813768068633552x.
):*40579994233264782x.*:*142803567979080632x.+:*362337120513956352x.,:
*470743312831578962x.-:*613547491249934042x..:*17957526371094812x./:*50779961661029192x.:
:*20491853432006122x.;:*570303310013009862x.<:*87401420665433592x.=:*43415441646108752x.>
:*268509698654182962x.?:*11798771132790041x.@:*39386465097285772x.[:
*44401297831106822x.\:*320235846317059162x.]:*3633130443147522x.^:*206937888890491172x
._:*10788532194783112x.`:*48050256370738312x.{:*37322877699895241x.|:
*285502181022810972x.}:*53934029076536811x.~:*62707294566989381x. :
*317845144847070072x.0:*332911003892408462x.1:*31242866866048922x.2:
*41169554762870472x.3:*97718378237706231x.4:*261980565974152282x.5:
*22881433404648212x.6:*09015504673690541x.7:*31500322841391x.8:
*04865304598010241x.9:*3773949171038621x._FAST_False                
        

Dabei zeigt die letzte Zahl vor dem x, wie viele Stellen vor dem Komma besetzt wären. Wie beispielsweise das erste Elemente von oben: a:*33851544063138082x.b. Der Winkel wäre somit: für a = 33.85154406313808

Verschlüsselung

Zur Verschlüsselung werden die zuvor generierten Vektoren wieder gebraucht. Denn diese ersetzen nun die verfasste Nachricht. So könnte beispielsweise die Nachricht Hallo verschlüsselt so aussehen:

549-252-980-880-351-762-125-710-159-904-161-823-763-506-885-922-
938-227-524-187-86-502-615-56-938-227-524-187-86-502-615-56-811-
300-254-686-20-903-853-529-

Welche Zahlen bei der Erstellung der Vektoren letzendlich benutzt werden dürfen, kann flexibel angepasst werden. Man sollte nur bedenken, der diese Variablen in deinen RAM gespeichert werden müssen und dessen Größe nicht endlich ist.

Entschlüsselung

Die Entschlüsselung geht den Weg der Verschlüsselung nur Rückwärts. Zu Beginn müssen natürlich die "kryptischen" Zeichen geordnet gespeichert werden um zunächst aus den Vektoren wieder dessen Schnittwinkel berechnen zu können. Danach können die berechneten Schnittwinkel mit den im Schlüssel enthaltenden Winkel abgeglichen werden.

Abschließende Worte

Mir ist natürlich bewusst, dass der Code weder effizient, noch ressourcenschonend ist, dennoch könnte man diese Verschlüsselung relativ einfach mit weiteren Features ausstatten. Man könnten beispielsweise drei-dimensionale-Vektoren benutzen und mit hashlib arbeiten, um die Ausgabe noch "kryptischer" zu gestalten. Außerdem muss ja nicht bei Geradengleichungen gestoppt werden. Es gäbe noch die Möglichkeit die Verschlüsselung auf Ebenen anzuwenden. Da ist der "algebraischen Kreativität" keine Grenzen gesetzt!