Aufgabe 1

Aufgabe 2.1

Regeln

• p und q dürfen nicht aufeinander folgen
• e muss teilerfremd zu φ(n) sein

Schlüssel erzeugen

• Lege fest p = 11
• Lege fest q = 17
• Berechne n = p * q → n = 11 * 17 = 187
• Berechne φ(n) = |ℤ_n^*| = (p-1)(q-1) → φ(187) = (11-1)(17-1) = 10*16 = 160
• Lege fest e = 23
• e*d = 1 mod 160
• Berechne d = 7 (Solange n erhöhen bis (1+160*n) / 23 eine ganze Zahl liefert)

Verschlüsselung

• Lege fest m = 3
• Berechne C = m^e mod n → C = 3²³ mod 187 = 94.143.178.827 = 181 mod 187

Entschlüsselung

• Gesucht m = C^d = 181⁷ mod 187
• 7 = 1*2² + 1*2¹ + 1*2⁰ = ((2 + 1) * 2) + 1
• 181⁷ = ((181)² * 181)² * 181
• 181 * 181 = 121 mod 187
• 121 * 181 = 141 mod 187
• 141 * 141 = 41 mod 187
• 41 * 181 = 3 mod 187 = m

Aufgabe 2.2

• Lege fest e = 3
• Lege fest p = 5
• Lege fest q = 11
• Berechne n = p*q = 55
• Lege fest m = 4
• c₁ = m³ mod n = 64³ mod 55
• c₂ = (m+1)³ mod n = 4³ mod 55 = 125 mod 55
• m = (c₂ + 2*c₁ – 1) / (c₂ – c₁ + 2)
• m = (125 + 128 – 1) / (125 – 64 + 2) = 252 / 63 = 4

Aufgabe 3

Symmetrisch

• Im Hintergrund läuft PKI

Nutzer A:

1. Wähle x
2. Berechne g^x
3. Sig(g^*, sk_A) = S_A
4. Senden → S_A, g^x
5. Prüfe S_B
6. (g^y)^x

Nutzer B:

1. Wähle y
2. Berechne g^y
3. Sig(g^y, sk_B) = S_B
4. Senden → S_B, g^y
5. Prüfe S_A
6. (g^x)^y

Asymmetrisch

• Diffie Hellman mit mindestens 2048 Bit
• → Vergleiche Abbildung 7.2

Aufgabe 4

Beispiel: Nils ruft beim Support an, weil er ein Problem mit seinem PC hat. Der Angriff erfolgt über die Replay-Attacke.

Ablauf

1. Techniker sagt Nils er soll authentifizieren
2. Nils bekommt die Zufallszahl (Challenge)
3. Nils berechnet den Hashcode mit dem geheimen Schlüssel vom Techniker
4. Nils schickt den Hashcode zurück
5. Techniker prüft, ob der übermittelte Hashcode mit dem selbst berechneten übereinstimmt
6. Max hört zu und merkt sich den Hashcode
7. Max ruft beim Techniker an, lässt sich die Zufallszahl senden und schickt den von Nils bekannten Hashcode zurück
8. Max ist nun als Nils authentifiziert

Der Beitrag Kryptologie (Praktikum 6) erschien zuerst auf Maximilian Krieg.

Erinnerung

• Asymmetrisches Verfahren Öffentlichen Schlüssel / Public Key / PK → Verschlüsseln
• Geheimer Schlüssel / Secret Key / SK → Entschlüsseln

Daten authentizitieren (z.B. Signatur)

• SK → Daten signieren
• PK → Signatur verifizieren

Instanzauthentisierung (über Challenge Response)

• SK → Zufall (Challenge) signieren
• PK → Signatur verifizieren

Ziele

• Zuordnung des Schlüssels zum Schlüsselinhaber
• Für wen verschlüssle ich eigentlich?
• Wer hat Daten signiert?
• Wer authentisiert sich da gerade?

Schlüsselnutzung

• Für alle Verfahren verschiedene Schlüssel
• Wir haben Angriffe gesehen (Sende Dokument → Bekomme es signiert zurück → Fatal!)
• Etablieren einer gemeinsamen Sicherheitsinfrastruktur
• Wie sicher sind Schlüssel gelagert?
• Wie stark ist die Bindung zwischen Schlüssel und Schlüsselinhaber?
• Wie sieht ein Registrierungsprozess aus?

Erste Lösung

• 2 Personen → 1 Austausch
• 3 Personen → 3 Austausch
• 4 Personen → 6 Austausch
• n Personen → n(n-1)/2 Austausch
• Kommt eine neue Personen hinzu, muss diese mit allen anderen Personen den Schlüssel austauschen

Besser – Public Key Infrastrukturen

• Die öffentlichen Schlüssel aller Kommunikationspartner werden von einer zentralen vertrauenswürdigen Instanz verwaltet
• Jeder Nutzer erhält ein Zertifikat für seinen öffentlichen Schlüssel
• Zertifikat wird ausgestellt von der Certification Authority (CA)

Aufbau eines Zertifikats

Beispiel 10.1

1. Nutzer 1 signiert Dokument m mittels sk₁ → Signatur s = sig(m, sk₁)
2. Nutzer 1 sendet m, s und C₁ an N2
3. Nutzer 2 verifiziert C₁ mittels pk_CA
4. Nutzer 2 prüft Angaben zur Person, Schlüsselnutzung und Gültigkeit
5. Nutzer 2 nutzt pk₁ (enthalten in C₁), um s zu prüfen

Registration Authority (RA)

• Prüft Zertifizierungsanträge
• Legt Inhalte der Zertifikate fest
• Leitet Anträge an die CA weiter
• CA stellt die Zertifikate aus

Mehrstufige CA

Zurückziehe von Zertifikaten

• Eine Instanz (Teil CA oder ein Endnutzer) hält sich nicht an Sicherheitsvorgaben → Hierzu müssen Certification Revokation Lists (CRL) geführt werden
• Bei Sicherheitsvorfällen (z.B. bei Schlüsselkompromittierung, Algorithmus wird unsicher )
• Prüfung, ob Zertifikat in CRL enthalten ist

Certificate Policy und Certificate Practice Statement

• Alle Instanzen einer PKI (z.B: Root-CA, Teil-CAs und Endnutzer) müssen ein definiertes Maß an Sicherheit einhalten
• Root gibt dazu 2 Dokumente aus:
  • Certificate Policy (Öffentliches Dokument) – Welche Sicherheitsvorgaben müssen eingehalten werden
  • Certificate Practice Statement (Internes Dokument für Mitarbeiter) – Beschreibt, wie diese Sicherheitsvorgaben eingehalten werden
• Beispiel
  • Schlüssel so gesichert sein, dass sie dritten nicht zugänglich sind
  • Wir speichern Schlüssel in einem High Security Module
• RFC 3647 – Internet X509 Public Key Infrastructure Certificate Policy and Certification Practices Framework beschreibt Aufbau und Inhalte beider Dokumente

Klausur

Wie funktioniert die Erkennung gültiger Zertifikate und eines signierten Dokumentes von Benutzern, die zu einer anderen Teil-CA gehören?

Der Beitrag Kryptologie (Vorlesung 12) erschien zuerst auf Maximilian Krieg.

Zufallszahlengeneratoren

Zweck

• Schlüsselgenerierung
• Asymmetrischen Verschlüsselungsverfahren (Padding für RSA)
• Zufall im Challenge-Response-Verfahren

Wichtig

• Die Güte des Zufalls, die Unvorhersagbarkeit → mit x₁, … , x₁₂₈ ∈ {0,1}
• Sicherheitsniveau ist 2¹⁰⁰ Versuche = 1/2¹⁰⁰

Entropie

• Wird in Bit gemessen
• „Entropie von n Bit“ bedeutet die Wahrscheinlichkeit den Zufallswert zu erraten, ist 1 / (2ⁿ)
• Schlüssel (x₁ , … , x₁₂₈) benötigt eine Entropie von 100 Bit
• Schlüssel der Länge 128 Bit mit Entropie von 128 Bit bedeutet, dass jedes Bit im Schlüssel hat Entropie von 1 Bit
  • Pr(x₁=0) = 1/2
  • Pr(x₁=1)=1/2
• Wir unterscheiden hier zwischen physikalischen und deterministischen Zufallsgeneratoren

Physikalische Generatoren

Zufall aus physikalischen Rauschquellen

• Impulsschwankungen elektromagnetischer Schaltungen
• radioaktiver Zerfall
• Atmosphärenrauschen

Probleme

• Nicht immer verfügbar
• Häufig langsam, die Zeit bis genug Zufall gesammelt wurde ist lang
• Häufige Schiefen (mehr Einsen als Nullen oder umgekehrt → Keine Gleichverteilung)
• Eine Schiefe, die Wahrscheinlichkeit aufzutreten, bedeutet, dass die Wahrscheinlichkeit größer als 1/2 ist

Lösung

• Deterministische Nachbearbeitung

Sicherheit (BSI-Empfehlung)

1. Beschreiben der Rauschquellen durch ein stochastisches Modell
2. Der durchschnittliche Entropiezuwachs pro Zufallsbit liegt oberhalb einer gegebenen Mindestschranke

Beispiel

• Erzeugt wird eine Zufallsfolge x₁ , … , x_n ∈ {0,1}
• Entropiezuwachs pro Bit → Ideal = 1
• Wahrscheinlichkeit x₁ zu erraten = 1/2
• Wahrscheinlichkeit alles zu erraten = 1/(2ⁿ)
• Häufige Schiefen:
  • Pr(x₁=0)=0,2
  • Pr(x₁=1)=0,8
• Entropie von x₁:
  • Wahrscheinlichkeit x₁ zu erraten ist 0,8
  • Ausgedrückt in Entropie: 1/2^x = 0,8
  • x = 0,322 ≈1/3
  • Um 100 Bit Entropie zu erhalten, müssen x₁ bis x₃₀₀ erzeugt werden
• Deterministische Nachbearbeitung:
  • Aus 300 Bit mit Entropie 100 mache 100 Bit mit Entropie 100

Deterministische Zufallsgeneratoren

• Werden auch Pseudozufallsgeneratoren genannt
• Berechnen aus einem Zufallswert mit fester Länge, auch Seed genannt
• Der Seed ist eine Pseudozufällige Bitfolge praktisch beliebiger Länge

Hinweis

• Durch einen deterministischen Zufallsgenerator bzw. Nachbearbeitung kann die Entropie, die Zufälligkeit, nicht erhöht werden
• Je komplizierter der Generator ist, desto schwieriger ist es nachzuweisen, ob dieser wirklich funktioniert und sicher ist
• Wiederverwendbarkeit:
  • „Die Wiederverwendbarkeit des Seeds tritt ab zweitem Schritt auf.“
  • Für hashfunktion h : {0,1}^* → {0,1}²⁰⁰ erzeugt dieser deterministischer Zufallsgenerator in jedem Schritt 200 Bit Zufall mit Entropie min {200, Entropie (SEED)}

Sicherheit

• Entropieerhaltend
• Aus bekannter Zufallsfolge dürfen Vorgänger und Nachfolger nicht berechnet werden

Seedgenerierung

• Seed durch phyiskalische Zufallsgeneratoren generieren
• Am Computer durch mehrere unabhängige Systemaufrufe zusammen setzen
• Linux /dev/random:
  • Liefert mindestens 100 Bit Entropie (laut BSI)
  • Systemzeit, Nutzeraktivitäten (Programm öffnen, Fenster schließen, Mausposition)
• Windows:
  • Kombination verschiedener Systemaufrufe
  • Read Time Stamp Counter() = Prozessorzyklen seit Systemstart
  • Bei Taktfrequenz ≥ 1 GHz → 2³⁰ mögliche Werte pro Sekunde (Nicht 2³⁰ lang!)
  • KeQuerySystemTime() = Aktuelle Systemzeit (relativ zu 1970)
  • Auflösung beträgt 100ms → 2²³ verschiedene Werte pro Sekunde

Erzeugung

1. Starte Rechner
2. Starte Programm
   • A = RTSC();
   • B = KQST();
3. Verifizieren eines Logins
   • C = RTSC();
   • C‘ = KQST(); ← Lässt sich aus den anderen Aufrufen berechnen und bringt nichts mehr
4. Erzeugen des SEEDs
   • D = RTSC();
   • A||B||C||D = SEED
5. Erzeugter Seed hat eine Entropie von
   • 30+23+30+30 = 113

Der Beitrag Kryptologie (Vorlesung 11) erschien zuerst auf Maximilian Krieg.

Es gibt keine Aufgaben bis zum nächsten Praktikumstermin.

Der Beitrag Kryptologie (Praktikum 5) erschien zuerst auf Maximilian Krieg.

Wiederholung

• Diskretes Logarithmusproblem (Siehe Mitschrift vom 04.06.2011)
• Symmetrische Schlüssel zum Erreichen des gleichen Sicherheitsniveaus sind kürzer als asymmetrische Schlüssel

Beispiele für Gruppen zum DL

• ℤ_p^* = {1, … , p-1}

Eigenschaften

• Zyklisch:
  • Es gibt ein g ∈ ℤ_p^* mit {1, … , p-1} = {gⁿ, n ∈ ℕ}
  • Gruppe ℤ₅^* = {1, 2, 3, 4}
  • 3 ist ein Erzeuger (Das Verfahren zum Herausfinden folgt später)
  • 4 ist kein Erzeuger (Nicht jede Zahl in der Gruppe ist auch ein Erzeuger für diese Gruppe)
  • Ist g ∈ ℤ_p* ein Erzeuger, dann existiert für alle h ∈ ℤ_p^* ein x ∈ ℕ mit g^x = h
  • Dies bedeutet, dass log_gh = x existiert
• Daran lassen sich dann Schlüssel ableiten, z.B. für Secure Messaging (verschlüsselte und authentisierte Kommunikation)
  • K_E = Hashwert H (g^xy || 0x00) Verschlüsselungsschlüssel
  • K_E = Hashwert H (g^xy || 0x01) Schlüssel für Authentisierung

Angriff

• Angreifer kennt g, g^x, g^y
• Ziel ist es das gemeinsame Geheimnis g^xy heraus zu finden
• Derzeitig einzige Möglichkeit:
  • Bestimme x oder y, d.h. berechne log_g(g^x) = y oder log_g(g^y) = x
• Erster Ansatz über Probepotenzieren (Brute Force):
  1. Wähle x‘, berechne g^x‘ und vergleiche mit g^x‘ = gx
  2. Für p > 2¹⁰⁰ ist |ℤ_p*| > 2¹⁰⁰
  3. D.h. Wahrscheinlichkeit für Gleichheit kleiner als 2^-100 bzw. 1/2¹⁰⁰
  4. Man braucht also ca. 2¹⁰⁰ Versuche x zu finden (Sicherheitsniveau ist 100 Bit)
  5. Schnellster Algorithmus für das DLP (Diskretes Logarithmusproblem) O(e^{sqrt(log₁₀(p) * log₁₀(log₁₀p))})
  6. p ≈ 2⁴⁰⁰⁰ gilt log₁₀(2⁴⁰⁰⁰) ≈ 1200
  7. log₁₀(log₁₀ (2⁴⁰⁰⁰) ≈ 3
  8. sqrt(1200*3) = e⁶⁰ = 2⁹⁰

Erfolgreicher Angriff – Man in the middle

• Also: Das Verfahren muss mit Instanzauthentisierung einher gehen, um g^x / g^y den Kommunikationspartner zuordnen zu können

Secret Sharing

• Ziel: Durchsetzung eines Mehr-Augen-Prinzips
• Aufteilen eines Geheimnisses K (z.B. kryptographischer Schlüssel) in n Teilgeheimnisse so, dass
• t ≤ n Teilgeheimnisse notwendig sind um K zu erhalten
• t-1 Teile aber keinerlei Informationen über K liefern

(t, n) – Schwellwert – Schema

• (4,10) = Ich brauche 4 von 10 Teilen

Einfaches und unsicheres Verfahren:

• 128 bit Schlüssel in z.B. 4 Teile aufteilen
• K = {K₁, … , K₂₂ , … , K₁₂₈}
• K₁ bis K₂2 = Teilschlüssel 1, usw.
• Mit 3 Teilen des Schlüssels ließen sich z.B. schon 96 Bit wieder herstellen, d.h. es werden Informationen über K geliefert

Einfaches und sicheres Verfahren

1. Wähle zufällig n-1 Werte TK₁, … , TK_n-1 = {0,1}¹²⁸
2. Setze T,K_n = TK₁ ⊕ … ⊕ TK_n-1 ⊕ K
3. Dann gilt TK₁ ⊕ … ⊕ TK_n = K
4. Kennt man weniger als n Teilgeheimnisse erhält man keine Informationen über den Schlüssel K
5. Vergleichbar zum One-time-pad

Shamirs Secret Sharing (RSA) – (t,n)

• Idee: Verstecke K in einem Polyom
• Betrachte k ∈ {0,1}¹²⁸ als natürliche Zahl \( k = \sum_{i=1}^{128} * K_i * 2^{i-1}\)
• Wähle k-1 zufällig Werte a₁, … , a_t-1
• Betrachte f(x) = K + a₁ x¹ + a₂x² + … + a_t-1 x^t-1
• Dann gilt f(0) = K
• Erzeugen der Geheimnisse:
  • Pers 1 → (1,f(1))
  • Pers 2 → (2,f(2))
  • …
  • Pers n → (n,f(n))
• Lösche a₁ bis a_t-1
• Rekonstruktion des Polynoms:
  • Fundamentalsatz der Algebra: Polynom (t-1) Grades wird durch t Punkte (x_i, f(x_i)) ist eindeutig festgelegt
  • Es werden also t der n zuvor berechneten Werte benötigt
  • \( f(x) = \sum_{i=1}^{t}f(x_i) * \prod_{j=1 \wedge y\neq i }^{t}\frac{x-x_j}{x_i-x_j} \) (Lagrange-Formel)
  Sicherheit
  • t-1 (und weniger) Teile liefern keinerlei Informationen über k
  • Angreifer kennt t-1 Werte (1,f(1)) , … , (t-1, f(t-1))
  • \( K=f(0)=\sum_{i=1}^{t}f(i)*\prod_{j=1 \wedge j\neq i}^{t}\frac{0-j}{i-j} \)
  • \( K=f(0)=\sum_{i=1}^{t-1}f(i)*\prod_{j=1 \wedge j\neq i}^{t-1}\frac{0-j}{i-j} + f(t)*\prod_{j=1 \wedge j\neq i}^{t}\frac{0-j}{t-j} \)
  • Nur f(t) ist nicht bekannt
  • f(t) kann alle möglichen Werte annehmen, damit auch f(0) = K
  • D.h. Angreifer hat keinerlei Informationen über K

Der Beitrag Kryptologie (Vorlesung 10) erschien zuerst auf Maximilian Krieg.

Instanzauthentisierung

• „Ist mein Gegenüber derjenige, der er vorgibt zu sein“ → Schutzziel Authentizität (Siehe Definition 1.3)
• Beweisender (derjenige, der sich authentisieren will) weist dem Prüfer den Besitz eines Geheimnisses nach
• Typisches Beispiel: Benutzername und Kennwert

Challenge Response Verfahren

• Siehe Abbildung 6.1
• Kommt z.B. bei SSL und HTTPS zum Einsatz

Grundlage (kryptographische Primitive) – Verfahren zur Datenauthentisierung

Nutzung von symmetrischen Verfahren (MAC)

• Zu P und B muss vorab ein symmetrischer Schlüssel ausgetauscht werden
• B weist im Rahmen des Protokolls nach, dass er den Schlüssel kennt ohne diesen zu übermitteln

Nutzung von asymmetrischen Verfahren (Signatur)

1. B nutzt zur Berechnung der Prüfsumme seinen geheimen Schlüssel
2. P prüft mittels zugehörigem öffentlichen Schlüssel
3. P muss den öffentlichen Schlüssel dem B zuordnen können (benötigt Public-Key-Infrastruktur)

Wichtig

• Schlüssel für Datenauthentisierung und Instanzauthentisierung müssen verschieden sein

Angriff

• Angreifer erzeugt eine Nachricht m und bildet M(m) = r
• Angreifer fordert B zur Authentisierung auf und sendet r
• B berechnet die Prüfsumme c
• B sieht nicht, ob r Zufall oder Hashwort einer Nachricht ist
• Beim Angreifer liegt eine von B korrekt signierte Nachricht vor

Schlüsseleingangsverfahren

• Ziel ist es den Austausch bzw. die Einigung von Schlüsseln über unsichere Kanäle sicher zu gestalten
• Beispiel:
  1. A möchte B ein Geheimnis schicken
  2. Fährmann F ist aber nicht vertrauenswürdig
  3. A sichert Kiste mit Schloss 1
  4. F übergibt Kiste an B
  5. B sichert mit Schloss 2
  6. F übergibt Kiste an A
  7. A öffnet Schloss 1
  8. F übergibt B die Kiste
  9. B kann die Kiste öffnen
• Das Verfahren ist jedoch nicht sicher, da A nicht weiß (sobald er F aus den Augen verliert) ob F nicht das Schloss 2 anbringt und sich als B ausgibt → Man in the Middle
• Über authentische Schlösser ist gewährleistet, dass Schloss 2 zu B gehört

Mögliche Verfahren

• Einsatz von symmetrischen und asymmetrischen Verschlüsselungsverfahren
• Regelmäßiger Austausch kryptographischer Schlüssel, um Folgen von Schlüsselkompromittierungen gering zu halten
• Neue Idee:
  • Diffie-Hellmann-Schlüsseleingangsverfahren (Diffie-Hellmann, Meckle)
  • Das Verfahren beruht auf der vermuteten Schwierigkeit des Diskreten Logarithmusproblems in bestimmten Gruppen.

Diskretes Logarithmusproblem

• Eingabe: Zwei Zahlen g, h ∈ G
• Ausgabe: log_ah, d.h. x ∈ ℕ mit g^x = h
• Eine Gruppe G heißt kryptographisch stark, wenn das DL-Problem in G praktisch nicht lösbar ist (Sicherheitsniveau 100 bit)
• Für solche Gruppen ℤ_p^* = {1 , … , p-1}, p sehr große Primzahl (a * b = a * b mod p)
• Eigenschaften:
  • Diese Gruppen sind zyklisch, d.h. es gibt g ∈ ℤ_p^* mit {gⁿ, n ∈ ℕ} = {1, 2, … , p-1}
  • g ist dann Erzeuger der Gruppe insbesondere ℤ_p^* = {gⁿ, ≤ n ≤ p-1}
• Beispiele:
  • ℤ₅^* = {1, 2, 3, 4}
  • 3¹ = 3 mod 5
  • 3² = 9 = 4 mod 5
  • 3³ = 27 = 2 mod 5
  • 3⁴ = 81 = 1 mod 5
  • 2 und 3 sind Erzeuger
  • 1 und 4 sind keine Erzeuger (können alle Zahlen erzeugen)

Angriff

1. Öffentlich bekannt g^x, g^y, g
2. Angreifer berechnet log_g(g^x) = x
3. Angreifer berechnet (g^y)^x = g^xy

Der Beitrag Kryptologie (Vorlesung 9) erschien zuerst auf Maximilian Krieg.

Schwerpunkte der Klausur

1. Symmetrische und Asymmetrische Verschlüsselung
2. Funktionsweise von Blockchiffren und RSA
3. Schlüsseleinigungsverfahren
4. Angriffsmöglichkeiten wie „Man in the Middle“
5. Public Key Infrastruktur

Der Beitrag Kryptologie (Klausurvorbereitung) erschien zuerst auf Maximilian Krieg.

main.cpp

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include "myGUI.h"


// Using-Deklarationen
using namespace std;

int main(int argc, char** argv) {
    //Start GUI
    myGUI gui;
}// main

myAES.h

#ifndef MYAES_H
#define	MYAES_H

#include <iostream>

using namespace std;
// Typedefs
typedef unsigned char uchar;

class myAES {
public:
    // Konstruktoren/Destruktoren
    myAES();
    virtual ~myAES();

    // Manuelle Eingabe
    void enterKlartext();
    void enterSchluessel();

    // Set/Get-Methoden
    void setKlartext(uchar[16]);
    void setSchluessel(uchar[16]);
    void setCiphertext(uchar[16]);
    uchar* getKlartext();
    uchar* getSchluessel();
    uchar* getCiphertext();

    // Crypt
    void crypt(bool);
    void mixcolumns();
    void shiftrows();
    void schluesselexpansion(uchar[][44], int, int, int);
    void rotword(uchar[], int);
    uchar mix(uchar, unsigned int);
    void subbytes(uchar [], uchar [], int);
    
    // Decrypt
    void decrypt(bool);
    uchar gmul(uchar, uchar);
    void invert_mixcolumns();
    void invert_shiftrows();    
    
private:
    uchar klartext[16];
    uchar schluessel[16];
    uchar ciphertext[16];
};



#endif	/* MYAES_H */

myAES.cpp

#include "myAES.h"

using namespace std;

//<editor-fold defaultstate="collapsed" desc="Boxen">

unsigned char Sbox[256] = {//  s-box
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};

unsigned char sbox_inverse[256] = {
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};

unsigned char Rcon[256] = {
    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
    0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
    0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
    0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
    0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
    0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
    0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
    0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
    0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
    0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
    0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
    0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
    0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
    0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
    0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
};
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="AES-Methoden">

void myAES::subbytes(uchar sbox[], uchar tmp[], int arrSize) {
    for (int i = 0; i < arrSize; i++) {
        tmp[i] = sbox[tmp[i]];
    }
}// subbytes

uchar myAES::mix(uchar byte, unsigned int mixvalue) {
    unsigned char retValue;
    switch (mixvalue) {
        case 1:
            retValue = byte;
            break;
        case 2:
            retValue = byte << 1;
            if (byte & 0x80) {
                retValue = retValue ^ 0x1b;
            }
            break;
        case 3:
            retValue = byte << 1;
            if (byte & 0x80) {
                retValue = retValue ^ 0x1b;
            }
            retValue = retValue^byte;
            break;
    }
    return retValue;
}

void addRoundKey(uchar array[], uchar matrix[][44], int iReihe, int iSpalte, int iRunde) {
    int pos = 0;
    for (int i = iRunde * 4; i < ((iRunde * 4) + 4) && i < iSpalte; i++) {
        for (int k = 0; k < iReihe; k++) {
            array[pos] = array[pos] ^ matrix[k][i];
            pos++;
        }
    }
}// addroundkey

void myAES::rotword(uchar column[], int iReihe) {
    uchar tmp = column[0];
    for (int i = 1; i < iReihe; i++) {
        column[i - 1] = column[i];
    }
    column[iReihe - 1] = tmp;
} // rotword

void myAES::schluesselexpansion(uchar matrix[][44], int iReihe, int iSpalte, int iLaenge) {
    // Alle Spalten durchlaufen
    int pos = 0;

    for (int i = 0; i < iSpalte; i++) {
        if (i < 4) { // Schluessel in erste vier Spalten kopieren
            for (int k = 0; k < iReihe && pos < iLaenge; k++) {
                matrix[k][i] = schluessel[pos];
                pos++;
                //cout << hex << "matrix[" << k << "][" << i << "] = " << (int) matrix[k][i] << endl;
            }
        } else { // i > 4
            if (i % 4 == 0) {// erste Spalte eines Schluessels
                // Spalte in Hilfsarray kopieren
                uchar tmp[iReihe]; // i-1
                uchar tmp2[iReihe]; // i-4
                for (int k = 0; k < iReihe; k++) {
                    tmp[k] = matrix[k][i - 1];
                    tmp2[k] = matrix[k][i - 4];
                }

                rotword(tmp, iReihe);

                subbytes(Sbox, tmp, iReihe);

                // Spalte[i-4] XOR subbytes[rotword[i-i]
                for (int k = 0; k < iReihe; k++) {
                    tmp[k] = tmp[k] ^ tmp2[k];
                }

                // tmp[0] XOR (i/4)
                tmp[0] = tmp[0] ^ Rcon[i / iReihe];

                // tmp[k] an Spalte[k][i] kopieren
                for (int k = 0; k < iReihe; k++) {
                    matrix[k][i] = tmp[k];
                }

            } else {
                //cout << "i " << i << endl;
                for (int k = 0; k < iReihe; k++) {
                    matrix[k][i] = matrix[k][i - 4] ^ matrix[k][i - 1];
                }
            }
        }
    }
}// schluesselexpansion

void myAES::shiftrows() {
    uchar copys[16] = {};

    //reihe 1   
    copys[0] = ciphertext[0];
    copys[4] = ciphertext[4];
    copys[8] = ciphertext[8];
    copys[12] = ciphertext[12];

    //reihe 2
    copys[1] = ciphertext[5];
    copys[5] = ciphertext[9];
    copys[9] = ciphertext[13];
    copys[13] = ciphertext[1];

    // reihe 3
    copys[2] = ciphertext[10];
    copys[6] = ciphertext[14];
    copys[10] = ciphertext[2];
    copys[14] = ciphertext[6];

    //reihe 4
    copys[3] = ciphertext[15];
    copys[7] = ciphertext[3];
    copys[11] = ciphertext[7];
    copys[15] = ciphertext[11];

    //umschreiben   
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = copys[i];
    }
}// shiftrows

void myAES::mixcolumns() {
    for (int i = 0; i < 4; i++) {
        uchar sj0 = mix(ciphertext[i * 4], 2)^mix(ciphertext[i * 4 + 1], 3)^mix(ciphertext[i * 4 + 2], 1)^mix(ciphertext[i * 4 + 3], 1);
        uchar sj1 = mix(ciphertext[i * 4], 1)^mix(ciphertext[i * 4 + 1], 2)^mix(ciphertext[i * 4 + 2], 3)^mix(ciphertext[i * 4 + 3], 1);
        uchar sj2 = mix(ciphertext[i * 4], 1)^mix(ciphertext[i * 4 + 1], 1)^mix(ciphertext[i * 4 + 2], 2)^mix(ciphertext[i * 4 + 3], 3);
        uchar sj3 = mix(ciphertext[i * 4], 3)^mix(ciphertext[i * 4 + 1], 1)^mix(ciphertext[i * 4 + 2], 1)^mix(ciphertext[i * 4 + 3], 2);
        ciphertext[i * 4] = sj0;
        ciphertext[i * 4 + 1] = sj1;
        ciphertext[i * 4 + 2] = sj2;
        ciphertext[i * 4 + 3] = sj3;
    }
}// mixcolumns

void myAES::crypt(bool output) {

    // Parameter
    int iRunde = 10;
    int iLaenge = 16;

    // Überschreibe ciphertext um diesen fortan zu verwenden
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = klartext[i];
    }

    // Arraygroesse dynamisch bestimmen
    int arrSize = sizeof (ciphertext) / sizeof (ciphertext[0]);

    // Zwischenspeicherung der Rundenschluessel
    int iReihe = 4;
    int iSpalte = 4 * (iRunde + 1);
    uchar carrRundenschluessel[4][44];

    // Schluessel expandieren
    schluesselexpansion(carrRundenschluessel, iReihe, iSpalte, iLaenge);

    // Vorrunde
    for (int k = 0; k < iLaenge; k++) {
        ciphertext[k] = ciphertext[k] ^ schluessel[k];
    }

    // Durchlaufen der Runden
    for (int i = 1; i < iRunde + 1; i++) {

        // S-Box
        subbytes(Sbox, ciphertext, arrSize);

        // Shift Rows
        shiftrows();

        // Mix Columns
        if (i != (iRunde)) { // kein MixColumns in der letzten Runde
            mixcolumns();
        }

        // Rundenschlüssel addieren
        addRoundKey(ciphertext, carrRundenschluessel, iReihe, iSpalte, i);

    }
}

void myAES::invert_shiftrows() {
    uchar copys[16] = {};

    //reihe 1   
    copys[0] = klartext[0];
    copys[4] = klartext[4];
    copys[8] = klartext[8];
    copys[12] = klartext[12];

    //reihe 2
    copys[1] = klartext[13];
    copys[13] = klartext[9];
    copys[9] = klartext[5];
    copys[5] = klartext[1];

    // reihe 3   
    copys[6] = klartext[14];
    copys[2] = klartext[10];
    copys[14] = klartext[6];
    copys[10] = klartext[2];

    //reihe 4
    copys[11] = klartext[15];
    copys[7] = klartext[11];
    copys[3] = klartext[7];
    copys[15] = klartext[3];

    //umschreiben   
    for (int i = 0; i < 16; i++) {
        klartext[i] = copys[i];
    }
}// invert_shiftrows

void myAES::invert_mixcolumns() {
    for (int i = 0; i < 4; i++) {
        uchar sj0 = gmul(klartext[i * 4], 14)^gmul(klartext[i * 4 + 1], 11)^gmul(klartext[i * 4 + 2], 13)^gmul(klartext[i * 4 + 3], 9);
        uchar sj1 = gmul(klartext[i * 4], 9)^gmul(klartext[i * 4 + 1], 14)^gmul(klartext[i * 4 + 2], 11)^gmul(klartext[i * 4 + 3], 13);
        uchar sj2 = gmul(klartext[i * 4], 13)^gmul(klartext[i * 4 + 1], 9)^gmul(klartext[i * 4 + 2], 14)^gmul(klartext[i * 4 + 3], 11);
        uchar sj3 = gmul(klartext[i * 4], 11)^gmul(klartext[i * 4 + 1], 13)^gmul(klartext[i * 4 + 2], 9)^gmul(klartext[i * 4 + 3], 14);
        klartext[i * 4] = sj0;
        klartext[i * 4 + 1] = sj1;
        klartext[i * 4 + 2] = sj2;
        klartext[i * 4 + 3] = sj3;
    }
}

uchar myAES::gmul(uchar a, uchar b) {
    unsigned char p = 0;
    unsigned char hi;

    for (int i = 0; i < 8; ++i) {
        if ((b & 1) == 1)
            p ^= a;
        hi = (a & 0x80);
        a <<= 1;
        if (hi == 0x80)
            a ^= 0x1b;
        b >>= 1;
    }
    return p;
}

void myAES::decrypt(bool output) {

    // Parameter
    int iRunde = 10;
    int iLaenge = 16;


    // Überschreibe klartext um diesen fortan zu verwenden
    for (int i = 0; i < 16; i++) {
        klartext[i] = ciphertext[i];
    }

    // Arraygroesse dynamisch bestimmen
    int arrSize = sizeof (klartext) / sizeof (klartext[0]);

    // Zwischenspeicherung der Rundenschluessel
    int iReihe = 4;
    int iSpalte = 4 * (iRunde + 1);
    uchar carrRundenschluessel[4][44];

    // Schluessel expandieren
    schluesselexpansion(carrRundenschluessel, iReihe, iSpalte, iLaenge);

    // "neue" Vorrunde
    addRoundKey(klartext, carrRundenschluessel, iReihe, iSpalte, 10);

    // Durchlaufen der Runden
    for (int i = 9; i > 0; i--) {

        // Shift Rows
        invert_shiftrows();

        // S-Box
        subbytes(sbox_inverse, klartext, arrSize);

        // Rundenschlüssel addieren
        addRoundKey(klartext, carrRundenschluessel, iReihe, iSpalte, i);

        // Mix Columns
        if (i != 10) { // kein MixColumns in der letzten Runde
            invert_mixcolumns();
        }
    }

    // Letzte Runde
    invert_shiftrows();
    subbytes(sbox_inverse, klartext, arrSize);

    for (int k = 0; k < iLaenge; k++) {
        klartext[k] = klartext[k] ^ schluessel[k];
    }
}// decrypt

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Konstruktur/Destruktor">

myAES::myAES() {
    uchar kt[16] = {0x61, 0x62, 0x62, 0x69, 0x6c, 0x64, 0x75, 0x6e, 0x67, 0x73, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78};
    uchar s[16] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31};
    //uchar c[16] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31};
    for (int i = 0; i < 16; i++) {
        schluessel[i] = s[i];
        klartext[i] = kt[i];
    }
}

myAES::~myAES() {
}
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Manuelle Eingabe">

void enterValues(uchar arr[], string name) {
    string tmp = "";
    int diff = 0;
    cout << name << ": (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << "\nWerte fuer den" << name << " zu groß. Trenne nach 16 Zeichen ab.\n(";
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << endl;
        }

        if (tmp.length() < 16) {
            cerr << "\nWert fuer den Klartext zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << endl;
        }

        for (int i = 0; i < 16; i++) {
            arr[i] = tmp[i];
        }
        cout << endl;

    }
}

void myAES::enterKlartext() {
    enterValues(klartext, "Klartext");
}

void myAES::enterSchluessel() {
    enterValues(schluessel, "Schluessel");
}

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Set/Get-Methoden">

void myAES::setCiphertext(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = tmp[i];
    }
}

void myAES::setKlartext(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        klartext[i] = tmp[i];
    }
}

void myAES::setSchluessel(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        schluessel[i] = tmp[i];
    }
}

uchar* myAES::getSchluessel() {
    return schluessel;
}

uchar* myAES::getCiphertext() {
    return ciphertext;
}

uchar* myAES::getKlartext() {
    return klartext;
}

//</editor-fold>

myCBC.h

#ifndef MYCBC_H
#define	MYCBC_H
#include "myAES.h"
#include <vector>
class myCBC {
public:
    // Konstruktoren / Destruktoren
    myCBC();
    virtual ~myCBC();
    
    //CBC
    void crypt(bool);
    void decrypt(bool);
    
    // Set/Get-Methoden
    void setKey(uchar[16]);
    void setIV(uchar[16]);
    void setKlartext(vector<uchar>);
    void setCiphertext(vector<uchar>);
    vector<uchar> getKlartext();
    vector<uchar> getCiphertext();
    uchar* getSchluessel();
    uchar* getIV();
    
    // Manuelle Eingabe
    void enterKey();
    void enterIV();
    void enterKlartext();
    
private:
    uchar iv[16];
    uchar key[16];
    vector<uchar> klartext;
    vector<uchar> ciphertext;
};

myCBC.cpp

#include "myCBC.h"
#include <math.h>
#include <iostream>
#include <iomanip>

using namespace std;

uchar* myCBC::getSchluessel() {
    return key;
}

vector<uchar> myCBC::getKlartext() {
    return klartext;
}

void enterValue(uchar arr[], string name) {
    string tmp = "";
    int diff = 0;
    cout << name << ": (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << "\nWerte fuer den" << name << " zu groß. Trenne nach 16 Zeichen ab.\n(";
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << endl;
        }

        if (tmp.length() < 16) {
            cerr << "\nWert fuer den Klartext zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << endl;
        }

        for (int i = 0; i < 16; i++) {
            arr[i] = tmp[i];
        }
        cout << endl;

    }
}

void myCBC::enterKey() {
    enterValue(key, "Schluessel");
}

void myCBC::enterIV() {
    enterValue(iv, "Initialisierungsvektor");
}

void myCBC::enterKlartext() {
    klartext.clear();
    string tmp = "";
    cout << "Klartext (Beliebig viele Zeichen):";
    if (cin >> tmp) {
        for (int i = 0; i < tmp.size(); i++) {
            klartext.push_back(tmp[i]);
        }
        cout << endl;
    }

    if (tmp.size() % 16 != 0) {
        cerr << "\nLetzter Klartext-Block nicht vollstaendig. Fuelle mit Nullen auf.\n";
        for (int i = 0; i < 16 - tmp.size() % 16; i++) {
            klartext.push_back('\0');
        }
        cout << endl;
    }
}

myCBC::myCBC() {

    // Default Parameter
    uchar newKey[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar newIV[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    uchar newKlartext[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};

    // Schluessel setzen
    for (int i = 0; i < 16; i++) {
        key[i] = newKey[i];
    }

    //IV setzen
    for (int i = 0; i < 16; i++) {
        iv[i] = newIV[i];
    }

    // Klartext setzen
    for (int i = 0; i < 16; i++) {
        klartext.push_back(newKlartext[i]);
    }
}

vector<uchar> myCBC::getCiphertext() {
    return ciphertext;
}

void myCBC::decrypt(bool print) {
    klartext.clear();

    uchar tmp_iv[16];
    for (int j = 0; j < 16; j++) {
        tmp_iv[j] = iv[j];
    }
    for (int i = 0; i < ciphertext.size() / 16; i++) {

        myAES a1;

        //Übergabe - Array
        uchar tmp[16];
        for (int k = 0; k < 16; k++) {
            tmp[k] = ciphertext[k + 16 * i];
        }

        // Ciphertext
        a1.setCiphertext(tmp);

        // Schluessel
        a1.setSchluessel(key);

        // decrypt
        a1.decrypt(false);

        // Resultat mit IV addieren / XOR
        for (int f = 0; f < 16; f++) {
            a1.getKlartext()[f] = a1.getKlartext()[f]^tmp_iv[f];
        }

        // Neuen IV festlegen und Klartext eintragen
        for (int l = 0; l < 16; l++) {
            tmp_iv[l] = a1.getCiphertext()[l];
            klartext.push_back(a1.getKlartext()[l]);
        }
    }
}

void myCBC::crypt(bool print) {
    ciphertext.clear();
    uchar tmp_iv[16];
    for (int i = 0; i < 16; i++) {
        tmp_iv[i] = iv[i];
    }

    for (int i = 0; i < klartext.size() / 16; i++) {

        myAES a1;
        a1.setSchluessel(key);

        //XOR in Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = klartext[j + 16 * i]^tmp_iv[j];
        }

        // Klartext
        a1.setKlartext(tmp);

        // crypt
        a1.crypt(false);


        for (int j = 0; j < 16; j++) {
            tmp_iv[j] = a1.getCiphertext()[j];
            ciphertext.push_back(a1.getCiphertext()[j]);
        }
    }
}

void myCBC::setKlartext(vector<uchar> kt) {
    // Padding mit 0
    if (kt.size() > klartext.size()) {
        int diff = kt.size() - klartext.size();
        for (int i = 0; i < diff; i++) {
            klartext.push_back(0x00);
        }
    }

    // Werte übertragen
    for (int i = 0; i < kt.size(); i++) {
        klartext.at(i) = kt.at(i);
    }
}

void myCBC::setIV(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        iv[i] = tmp[i];
    }
}

void myCBC::setKey(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        key[i] = tmp[i];
    }
}

myCBC::~myCBC() {
}

myECB.h

#ifndef MYECB_H
#define	MYECB_H

#include "myAES.h"
#include <vector>
class myECB {
public:
    // Konstruktoren / Destruktoren
    myECB();
    virtual ~myECB();
    
    //CBC
    void crypt(bool);
    void decrypt(bool);
    
    // Set/Get-Methoden
    void setKey(uchar[16]);
    void setKlartext(vector<uchar>);
    void setCiphertext(vector<uchar>);
    vector<uchar> getKlartext();
    vector<uchar> getCiphertext();
    uchar* getSchluessel();
    
    // Manuelle Eingabe
    void enterKey();    
    void enterKlartext();

private:
    uchar key[16];
    vector<uchar> klartext;
    vector<uchar> ciphertext;

};

#endif	/* MYECB_H */

myECB.cpp

#include "myECB.h"
#include <iomanip>
#include <iostream>

void myECB::enterKey() {
    string tmp = "";
    int diff = 0;
    cout << "Schluessel (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << "\nWerte fuer den Schluessel zu groß. Trenne nach 16 Zeichen ab.\n(";
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << endl;
        }

        if (tmp.length() < 16) {
            cerr << "\nWert fuer den Klartext zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << endl;
        }

        for (int i = 0; i < 16; i++) {
            key[i] = tmp[i];
        }
        cout << endl;
    }
}

vector<uchar> myECB::getKlartext() {
    return klartext;
}

void myECB::enterKlartext() {
    klartext.clear();
    string tmp = "";
    cout << "Klartext (Beliebig viele Zeichen):";
    if (cin >> tmp) {
        for (int i = 0; i < tmp.size(); i++) {
            klartext.push_back(tmp[i]);
        }
        cout << endl;
    }

    if (tmp.size() % 16 != 0) {
        cerr << "\nLetzter Klartext-Block nicht vollstaendig. Fuelle mit Nullen auf.\n";
        for (int i = 0; i < 16 - tmp.size() % 16; i++) {
            klartext.push_back('\0');
        }
        cout << endl;
    }
}

myECB::myECB() {

    // Default Parameter
    uchar newKey[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar newKlartext[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};

    // Schluessel setzen
    for (int i = 0; i < 16; i++) {
        key[i] = newKey[i];
    }

    // Klartext setzen
    for (int i = 0; i < 16; i++) {
        klartext.push_back(newKlartext[i]);
    }
}

vector<uchar> myECB::getCiphertext() {
    return ciphertext;
}

void myECB::decrypt(bool print) {
    klartext.clear();

    for (int i = 0; i < ciphertext.size() / 16; i++) {

        myAES a1;

        //Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = ciphertext[j + 16 * i];
        }

        // Ciphertext
        a1.setCiphertext(tmp);

        // Schluessel
        a1.setSchluessel(key);

        // crypt
        a1.decrypt(false);

        // Resultat mit IV addieren
        for (int j = 0; j < 16; j++) {
            klartext.push_back(a1.getKlartext()[j]);
        }
    }
}

void myECB::crypt(bool print) {
    ciphertext.clear();

    for (int i = 0; i < klartext.size() / 16; i++) {

        myAES a1;
        a1.setSchluessel(key);

        //XOR in Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = klartext[j + 16 * i]; //^tmp_iv[j];
        }

        // Klartext
        a1.setKlartext(tmp);

        // crypt
        a1.crypt(false);


        for (int j = 0; j < 16; j++) {
            ciphertext.push_back(a1.getCiphertext()[j]);
        }
    }
}

void myECB::setKlartext(vector<uchar> kt) {
    if (kt.size() > klartext.size()) {
        int diff = kt.size() - klartext.size();
        for (int i = 0; i < diff; i++) {
            klartext.push_back(0x00);
        }
    }
    for (int i = 0; i < kt.size(); i++) {
        klartext.at(i) = kt.at(i);
    }
}

void myECB::setKey(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        key[i] = tmp[i];
    }
}

myECB::~myECB() {
}

myGUI.h

#ifndef MYGUI_H
#define	MYGUI_H

#include <iostream>
#include "myCBC.h"
#include "myECB.h"

class myGUI {
public:
    // Menu
    myGUI();
    void menuAES();
    void menuCBC();
    void menuECB();
    // Tests
    bool checkAES();
    bool checkCBC();
    bool checkECB();
    virtual ~myGUI();
private:
};

#endif	/* MYGUI_H */

myGUI.cpp

//Präprozessor-Direktiven
#include "support.h"
#include "myGUI.h"
#include <vector>
#include <iostream>
#include  <iomanip>


//Namensbereich Auflösung
using namespace std;

// <editor-fold defaultstate="collapsed" desc="Methoden bzgl. AES">

bool myGUI::checkAES() {

    bool returnValue = false;

    // Testvektoren
    uchar schluessel[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar klartext_1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar klartext_2[16] = {0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51};
    uchar klartext_3[16] = {0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef};
    uchar cipher_1[16] = {0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60, 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97};
    uchar cipher_2[16] = {0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d, 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf};
    uchar cipher_3[16] = {0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23, 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88};

    // Test#1
    myAES aes1;
    aes1.setKlartext(klartext_1);
    aes1.setSchluessel(schluessel);
    aes1.crypt(false);

    // Test#2
    myAES aes2;
    aes2.setKlartext(klartext_2);
    aes2.setSchluessel(schluessel);
    aes2.crypt(false);

    // Test#3
    myAES aes3;
    aes3.setKlartext(klartext_3);
    aes3.setSchluessel(schluessel);
    aes3.crypt(false);

    // Prüfung
    bool isWorking = areEqual(aes3.getCiphertext(), cipher_3) && areEqual(aes2.getCiphertext(), cipher_2) && areEqual(aes1.getCiphertext(), cipher_1);
    if (isWorking) {
        returnValue = true;
    } else {

        returnValue = false;
    }
    return returnValue;
}

void myGUI::menuAES() {

    // Variablen initialisieren
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 4;
    int input = end;

    // aes initialisieren und verschlüsseln
    myAES aes;
    aes.crypt(false);

    //Menu Eingabe
    while (run) {
        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Text entschluesseln \n";
        cout << "(4) Zurueck\n";
        cout << "> ";

        // Eingabe überprüfen
        input = validatedInput(lowest, end);

        // Auswahl
        if (input == 1) {
            aes.crypt(true);
            printMatrix(aes.getKlartext(), "Klartext");
            printMatrix(aes.getSchluessel(), "Schluessel");
            printMatrix(aes.getCiphertext(), "Cipher");
        }
        if (input == 2) {
            aes.enterKlartext();
            aes.enterSchluessel();
            aes.crypt(true);
            printMatrix(aes.getKlartext(), "Klartext");
            printMatrix(aes.getSchluessel(), "Schluessel");
            printMatrix(aes.getCiphertext(), "Cipher");
        }
        if (input == 3) {
            aes.decrypt(true);
            printMatrix(aes.getCiphertext(), "Cipher");
            printMatrix(aes.getSchluessel(), "Schluessel");
            printMatrix(aes.getKlartext(), "Klartext");
        }
        if (input == end) {
            run = false;
        }
        if (input == -1) {

            cerr << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n";
            cout << endl;
        }
    }
}

// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="Methoden bzgl. CBC">

bool myGUI::checkCBC() {
    bool returnValue = false;

    // Test #1  - 16 Byte Testvektoren
    uchar keyB[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar ivB[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    uchar klartextB1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar ciphertextB1[16] = {0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d};

    // Container 
    vector<uchar> cipherB1;
    vector<uchar> ktB;

    // Container füllen
    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartextB1[i]);
        cipherB1.push_back(ciphertextB1[i]);
    }

    // cbc intialisieren
    myCBC cbcB;
    cbcB.setKey(keyB);
    cbcB.setIV(ivB);
    cbcB.setKlartext(ktB);

    // Verschlüsseln
    cbcB.crypt(false);

    // Test#2 - 32 Byte Testvektoren
    uchar klartextA1[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    uchar klartextA2[16] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
    uchar ivA[16] = {0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28, 0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58};
    uchar keyA[16] = {0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0, 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a};
    uchar ciphertextA1[16] = {0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a, 0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a};
    uchar ciphertextA2[16] = {0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9, 0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1};

    // Container
    vector<uchar> cipherA1;
    vector<uchar> test;

    // Container füllen
    for (int i = 0; i < 16; i++) {
        test.push_back(klartextA1[i]);
        cipherA1.push_back(ciphertextA1[i]);
    }

    for (int i = 0; i < 16; i++) {
        test.push_back(klartextA2[i]);
        cipherA1.push_back(ciphertextA2[i]);
    }

    // cbc initialisieren
    myCBC cbcA;
    cbcA.setKey(keyA);
    cbcA.setIV(ivA);
    cbcA.setKlartext(test);

    // Verschlüsseln
    cbcA.crypt(false);

    //Prüfung auf Korrektheit
    bool isWorking = areEqual(cbcA.getCiphertext(), cipherA1) && areEqual(cbcB.getCiphertext(), cipherB1);

    if (isWorking) {
        returnValue = true;
    } else {
        returnValue = false;
    }
    return returnValue;
}

void myGUI::menuCBC() {

    // cbc mit Standard Werten initialisieren
    myCBC cbc;
    cbc.crypt(false);

    // Variablen initialisieren
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 5;
    int input = end;

    //Menu Eingabe
    while (run) {
        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Bild ver- und entschluesseln\n";
        cout << "(4) Text entschluesseln\n";
        cout << "(5) Zurueck\n";
        cout << "> ";

        // Überprüfe Eingabe
        input = validatedInput(lowest, end);

        // Auswahl
        if (input == 1) {
            cbc.crypt(true);
            printMatrix(cbc.getKlartext(), "Klartext");
            printMatrix(cbc.getSchluessel(), "Schluessel");
            printMatrix(cbc.getCiphertext(), "Cipher");
        }
        if (input == 2) {
            cbc.enterIV();
            cbc.enterKey();
            cbc.enterKlartext();
            cbc.crypt(true);
            printMatrix(cbc.getKlartext(), "Klartext");
            printMatrix(cbc.getSchluessel(), "Schluessel");
            printMatrix(cbc.getCiphertext(), "Cipher");
        }
        if (input == 3) {
            //Fülle Vektor mit Punkten
            vector<uchar> myImg;
            fillImage(myImg);

            // Gebe Klartext aus
            printImage(myImg);

            // Setze Klartext, verschlüssle und gebe Cipher aus
            cbc.setKlartext(myImg);
            cbc.crypt(false);
            printImage(cbc.getCiphertext());

            // Entschlüssle und gebe Klartext aus
            cbc.decrypt(false);
            printImage(cbc.getKlartext());
        }
        if (input == 4) {
            cbc.decrypt(true);
            printMatrix(cbc.getCiphertext(), "Cipher");
            printMatrix(cbc.getSchluessel(), "Schluessel");
            printMatrix(cbc.getKlartext(), "Klartext");
        }
        if (input == end) {
            run = false;
        }
        if (input == -1) {
            cerr << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n";
            cout << endl;
        }
    }

}

// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="Methoden bzgl. ECB">

bool myGUI::checkECB() {
    bool returnValue = false;

    //16 Byte Testvektoren
    uchar schluessel[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};

    uchar klartext_1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar klartext_2[16] = {0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51};
    uchar klartext_3[16] = {0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef};

    uchar cipher_1[16] = {0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60, 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97};
    uchar cipher_2[16] = {0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d, 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf};
    uchar cipher_3[16] = {0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23, 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88};

    // Container
    vector<uchar> cipherB1;
    vector<uchar> ktB;

    // Fülle Container mit Block 1
    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_1[i]);
        cipherB1.push_back(cipher_1[i]);
    }

    // Fülle Container mit Block 2
    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_2[i]);
        cipherB1.push_back(cipher_2[i]);
    }

    // Fülle Container mit Block 3
    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_3[i]);
        cipherB1.push_back(cipher_3[i]);
    }

    // Verschlüssele mit Hilfe des Schlüssels und den 3 Blöcken
    myECB ecb;
    ecb.setKey(schluessel);
    ecb.setKlartext(ktB);
    ecb.crypt(false);

    //Prüfung auf Gleichheit
    bool isWorking = areEqual(ecb.getCiphertext(), cipherB1);
    if (isWorking) {
        returnValue = true;
    } else {
        returnValue = false;
    }
    return returnValue;
}

void myGUI::menuECB() {


    //Initialisiere ecb mit Standard-Werten
    myECB ecb;
    ecb.crypt(false);

    //Initialisiere Eingabe-Variablen 
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 5;
    int input = end;

    //Menu Eingabe
    while (run) {

        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Bild ver- und entschluesseln\n";
        cout << "(4) Text entschluesseln\n";
        cout << "(5) Zurueck\n";
        cout << "> ";

        // Prüfe Eingabe
        input = validatedInput(lowest, end);

        // Auswahl
        if (input == 1) {
            ecb.crypt(true);
        }
        if (input == 2) {
            ecb.enterKey();
            ecb.enterKlartext();
            ecb.crypt(true);
        }
        if (input == 3) {
            // Erstelle Vektor mit Bildpunkten
            vector<uchar> myImg;
            fillImage(myImg);

            // Gebe Klartext aus
            printImage(myImg);
            ecb.setKlartext(myImg);

            // Verschlpsseln und Gebe Cipher aus
            ecb.crypt(false);
            printImage(ecb.getCiphertext());

            // Entschlüsseln und Klartext ausgeben
            ecb.decrypt(false);
            printImage(ecb.getKlartext());
        }
        if (input == 4) {
            ecb.decrypt(true);
        }
        if (input == end) {
            run = false;
        }
        if (input == -1) {
            cerr << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n";
            cout << endl;
        }
    }

}

// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="Konstrukturen und Destruktoren">

myGUI::myGUI() {
    //Menu-Variablen

    unsigned int lowest = 1;
    unsigned int end = 4;
    int input = end;
    bool run = true;

    //Start
    cout << "#### Kryptographie Sommersemester 2013 ####\n";
    cout << "Nils Rogmann (725915) und Maximilian Krieg (725922)\n";

    // Begrüßung und Information
    cout << "\nHerzlich willkommen.\n";
    cout << "Das Programm wird nun mit Hilfe von Testvektoren geprueft.\n";

    // AES Check
    cout << "\nAES:\t\t";
    if (checkAES()) {
        cout << "OK";
    } else {
        cerr << "Fehler";
    }

    // CBC Check
    cout << "\nAES mit CBC:\t";
    if (checkCBC()) {
        cout << "OK";
    } else {
        cerr << "Fehler";
    }


    // ECB Check
    cout << "\nAES mit ECB:\t";
    if (checkECB()) {
        cout << "OK";
    } else {
        cerr << "Fehler";
    }

    cout << endl;

    //Menu Eingabe
    while (run) {
        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) AES\n";
        cout << "(2) AES mit CBC\n";
        cout << "(3) AES mit ECB\n";
        cout << "(4) Programm beenden\n";
        cout << "> ";

        // Prüfe Eingabe auf Gültigkeit
        input = validatedInput(lowest, end);

        // Aufrufe
        if (input == 1) {
            cout << "#### AES ####\n";
            menuAES();
            cout << endl;
        }

        if (input == 2) {
            cout << "#### AES mit CBC ####\n";
            menuCBC();
            cout << endl;
        }


        if (input == 3) {
            cout << "#### AES mit ECB ####\n";
            menuECB();
            cout << endl;
        }

        // Fehler
        if (input == -1) {
            cerr << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n";
            cout << endl;
        }

        // Beenden
        if (input == end) {

            cout << "Programm wird beendet.\n";
            run = false;
            cout << endl;
        }
    }
}//myGUI

myGUI::~myGUI() {
}//~myGUI

// </editor-fold>

support.h

#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;
typedef unsigned char uchar;

void printMatrix(vector<uchar> v, string name) {
    cout << name << ": \n";

    int add =0;
    for (int j = 0; j < v.size()/16; j++) {
        for (int i = 0; i < 4; i++) {
            cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i+add] << " ";
            cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 4+add] << " ";
            cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 8+add] << " ";
            cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 12+add] << " ";
            cout << endl;
        }
        add=add+16;
        cout << endl;
    }
    cout << endl;
}

void printMatrix(uchar v[16], string name) {
    cout << name << ": \n";
    for (int i = 0; i < 4; i++) {
        cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i] << " ";
        cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 4] << " ";
        cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 8] << " ";
        cout << hex << setfill('0') << setw(2) << nouppercase << (int) v[i + 12] << " ";
        cout << endl;
    }
    cout << endl;

    /*
    for (int i=0;i<16;i++)
        cout << hex<<(int) v[i];
     * */
}

int validatedInput(unsigned int lowest, unsigned int highest) {
    int tmp = 0;
    cin.clear();
    if (cin >> tmp) {//Eingabe ist in Ordnung
        cout << endl;
        if (tmp >= lowest && tmp <= highest) {//Eingabe liegt in den Parametern

            return tmp;
        }
    } else {
        // Falsche Inhalte verwerfen und Status zurücksetzen
        string trash = "";
        cin.clear();
        std::getline(std::cin, trash);
    }
    return -1;
}

// 16x16 Matrix ausgeben

void printImage(vector<uchar> myImg) {
    int add = 0;
    for (int j = 0; j < 4; j++) {
        for (int i = 0; i < 4; i++) {
            for (int k = 0; k <= 60; k) {
                cout << hex << setfill('0') << setw(2) << nouppercase << (int) myImg.at(i + k + add) << " ";
                k = k + 4;
            }
            cout << endl;
        }

        add = add + 64;
    }
    cout << endl << endl;
}

// 16x16 Matrix füllen

void fillImage(vector<uchar>& v) {
    // Alles auf 0 setzen
    // Außer den Inneren bereich, diesen auf 1
    for (int y = 0; y < 16; y++) {
        for (int x = 0; x < 16; x++) {
            if (y == 5 || y == 6 || y == 9 || y == 10)
                v.push_back(0x1);
            else {
                v.push_back(0x0);
            }
        }
    }

    //Manuell Randpunkte des Kreises setzen
    v[19] = 0x1;
    v[22] = 0x1;
    v[23] = 0x1;
    v[26] = 0x1;
    v[27] = 0x1;
    v[30] = 0x1;
    v[31] = 0x1;
    v[34] = 0x1;
    v[35] = 0x1;
    v[38] = 0x1;
    v[39] = 0x1;
    v[42] = 0x1;
    v[43] = 0x1;
    v[47] = 0x1;
    v[73] = 0x1;
    v[74] = 0x1;
    v[75] = 0x1;
    v[76] = 0x1;
    v[77] = 0x1;
    v[78] = 0x1;
    v[79] = 0x1;
    v[112] = 0x1;
    v[113] = 0x1;
    v[114] = 0x1;
    v[115] = 0x1;
    v[117] = 0x1;
    v[118] = 0x1;
    v[119] = 0x1;
    v[136] = 0x1;
    v[137] = 0x1;
    v[138] = 0x1;
    v[140] = 0x1;
    v[141] = 0x1;
    v[142] = 0x1;
    v[143] = 0x1;
    v[176] = 0x1;
    v[177] = 0x1;
    v[178] = 0x1;
    v[179] = 0x1;
    v[180] = 0x1;
    v[181] = 0x1;
    v[182] = 0x1;
    v[208] = 0x1;
    v[212] = 0x1;
    v[213] = 0x1;
    v[216] = 0x1;
    v[217] = 0x1;
    v[220] = 0x1;
    v[221] = 0x1;
    v[224] = 0x1;
    v[225] = 0x1;
    v[228] = 0x1;
    v[229] = 0x1;
    v[232] = 0x1;
    v[233] = 0x1;
    v[236] = 0x1;
}

// Gleichheitsprüfung

template<class T>
bool areEqual(T arr1, T arr2) {
    bool tmp = false;
    for (int i = 0; i < 16; i++) {
        if (arr1[i] == arr2[i]) {
            tmp = true;
        } else {
            cout << hex << arr1[i] << "!=" << arr2[i] << endl;
            tmp = false;
            break;
        }
    }
    return tmp;
}

Der Beitrag Kryptologie (Praktikum 4) erschien zuerst auf Maximilian Krieg.

Praktikum

• Das was abgegeben wurde ist in Ordnung
• Wenn etwas nicht stimmt, meldet er sich von selbst

Evaluation

• Wurde durchgeführt

Datenauthentisierung

• Garantiert, dass Daten nicht verändert wurden
• Dazu:
  • Beweisender (B) ist der Sender / Erzeuger von Daten
  • B berechnet mittels eines kryptographischen Schlüssels eine Prüfsumme über die zu authentifizierenden Daten
  • Prüfer (P) überprüft die Prüfsumme mittels eines kryptographischen Schlüssels
• Wir unterscheiden:
  1. Symmetrische Verfahren (Schlüssel zur Berechnung = Schlüssel zur Prüfung)
  2. Asymmetrische Verfahren (Schlüssel zur Berechnung ≠ Schlüssel zur Prüfung)

Message Authentication Code (MAC)

• Siehe auch: http://de.wikipedia.org/wiki/Message_Authentication_Code
• Symmetrisches Verfahren
• Basieren häufig auf Blockchiffren oder Hash-Funktionen
• B und P müssen vorab einen symmetrischen Schlüssel ausgetauscht haben

Erste Idee zur Umsetzung

• Basierend auf einer Hash-Funktion M:{0,1}^* → {0,1}ⁿ
• B und P vereinbaren Schlüssel k ∈ {0,1}¹²⁸

Erklärung

• Hashfunktion nach Merkle-Damgard
• || bedeutet „direkt hintereinander“
• H(k||m) = Funktion zur Berechnung der Prüfsumme
• k= Schlüssel
• m = Nachricht
• c = Prüfummse

Authentisierung

• B authentisiert m ∈ {0,1}^*
  1. Berechne c = M(k||m)
  2. Sende m und c an P

Prüfung

• P prüft Authentizität von m
  1. Berechne c‘ = M(k||m)
  2. Prüft ob c=c‘ gilt

Dieses Verfahren ist unsicher

• Angreifer kann weitere Blöcke an m hängen, Hashwert weiter rechnen und so eine gültige Prüfsumme berechnen
• Schützt also nur den Anfang einer Nachricht, aber nicht das Ende
  • → „Wir greifen morgen um 10 Uhr an“
  • → „Wir greifen morgen um 10 Uhr an, wenn es nicht regnet“
• Auch H(m||k) keine gute Idee, denn das schützt auch nur das Ende der Nachricht und nicht den Anfang

Beispiel für eine Length Extension Attack

• Normalerweise braucht ein Angreifer den Schlüssel um eine neue Prüfsumme zu erzeugen
• Mit einer Length Extension Attack wird die Prüfsumme wieder in die Hashfunktion eingegeben und man setzt am Ende wieder an
• Die Länge der ursprünglichen Nachricht muss dafür bekannt sein
• Neue Prüfsumme und Daten werden übermittelt

Sichere MAC-Verfahren

1. CMAC basiert auf Blockchiffren (C=Chiffre)
2. HMAC basiert auf Hash-Funktionen (Hash)
   • HMAC(k,m) = H((ko+opad)||H((ko+ipad)||m))
   • opad = 0x5C … 5C (Schlüssellänge)
   • ipad = 0x36 … 36 (Schlüssellänge)
   • H((ko+ipad)||m) → Sichert den Anfang der Nachricht ab
   • H((ko+opad)||H((ko+ipad)||m)) → Sichert das Ende der Nachricht ab

Verschlüsselungsverfahren und MAC-Verfahren

• Werden häufig zusammen geschaltet
• Secure Messaging
• Vertraulicher und authentischer Tunnel / Kanal
• MAC-Verfahren müssen nicht die Vertraulichkeitgarantieren
• MAC-Verfahren erfüllen nicht das Schutzziel Nichtabstreitbarkeit
  • Prüfer und und Beweisender verwenden den gleichen Schlüssel
  • Auch P könnte die Daten authentisiert haben
  • Gegenüber Dritten ist nicht nachweisbar, ob B oder P die Daten authentisiert hat
• Zwei Nebenbedingungen:
  1. Setze für Verschlüsselung und Datenauthentifizierung verschiedener Schlüssel ein („Trenne wo du trennen kannst“)
  2. Erst Verschlüsseln → dann verschlüsselte Daten Authentisieren (Vertraulichkeit ist ein anderes Schutzziel als Authentizität)

Signaturverfahren

• Sind asymmetrische Authentifizierungsverfahren
• B nutzt geheimen Schlüssel zur Berechnung der Prüfsumme
• P prüft mittels öffentlichem Schlüssel
• Erfüllt auch das Schutzziel Nichtabstreitbarkeit → Prüfsumme nur vom Inhaber des geheimen Schlüssels berechnet werden
• Zum Beispiel RSA oder Digital Signature Algorithm (DSA)

RSA

• B nutzt geheimen Schlüssel d um Prüfsumme S = m^d mod n zu berechnen
• P nutzt öffentlichen Schlüssel e um m‘ = s^e mod n zu berechnen
• Wegen (m^d)^e = mod n = m akzeptiert P, wenn m‘ = m
• Besteht aus:
  1. Hashfunktion H:{0,1}^* → {0,1}ⁿ ( Um Sicherheitsniveau 100 Bit zu erreichen muss n >= 200 sein)
  2. Einem Signaturalgorithmus

Problem

• Es können nur Nachrichten der Länge m ≤ n signiert werden
• Für n ≈2²⁰⁰⁰ als Bitlänge ≤ 2000

Lösung

• Nachricht m wird zunächst gehasht
• Signiert und geprüft wird dann H(m)
• Dazu wichtig: Hashfunktion muss kollisionsresistent sein
• Gilt für zwei Nachrichten m und m‘ → H(m) = H(m‘) → dann ist eine gültige Signatur für m auch eine für m‘

DSA

• Sicherheit beruhrt auf der vermuteten Schwere des Diskreten Logarithmusproblems in bestimmten endlichen Gruppen
• Diskretes Logarithmusprublem in Z^*_p = {1, … , p-1}
• Gegegeben: Zwei Elemente g,h ∈ Z^*_p
• Lösung: log_gh (d.h. x mit g^x = h)

Der Beitrag Kryptologie (Vorlesung 8) erschien zuerst auf Maximilian Krieg.

main.cpp

// Präprozessor-Direktiven
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include "myGUI.h"

// Using-Deklarationen
using namespace std;

int main(int argc, char** argv) {
    myGUI gui;
}// main

myGUI.h

#ifndef MYGUI_H
#define	MYGUI_H

#include <iostream>
#include "myCBC.h"
#include "myECB.h"

class myGUI {
public:
    myGUI();
    void callAES();
    void callCBC();
    void callECB();
    bool checkAES();
    bool checkCBC();
    bool checkECB();
    int validatedInput(unsigned int, unsigned int);
    virtual ~myGUI();
private:
};

#endif	/* MYGUI_H */

myGUI.cpp

#include "myGUI.h"
#include <vector>

using namespace std;

bool areEqual(vector<uchar> v1, vector<uchar> v2) {
    bool tmp = false;
    if (v1.size() == v2.size()) {
        for (int i = 0; i < v1.size(); i++) {
            if (v1[i] == v2[i]) {
                tmp = true;
            } else {
                cout << hex << v1[i] << "!=" << v2[i] << endl;
                tmp = false;
                break;
            }
        }
    }
    return tmp;
}

bool areEqual(uchar* arr1, uchar* arr2) {
    bool tmp = false;
    for (int i = 0; i < 16; i++) {
        if (arr1[i] == arr2[i]) {
            tmp = true;
        } else {
            cout << hex << arr1[i] << "!=" << arr2[i] << endl;
            tmp = false;
            break;
        }
    }
    return tmp;
}

bool myGUI::checkCBC() {
    bool returnValue = false;

    //16 Byte Testvektoren
    uchar keyB[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar ivB[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    uchar klartextB1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar ciphertextB1[16] = {0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d};
    vector<uchar> cipherB1;
    vector<uchar> ktB;

    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartextB1[i]);
        cipherB1.push_back(ciphertextB1[i]);
    }

    myCBC cbcB;
    cbcB.setKey(keyB);
    cbcB.setIV(ivB);
    cbcB.setKlartext(ktB);
    cbcB.crypt(false);

    // 32 Byte Testvektoren

    uchar klartextA1[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    uchar klartextA2[16] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
    uchar ivA[16] = {0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28, 0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58};
    uchar keyA[16] = {0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0, 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a};
    uchar ciphertextA1[16] = {0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a, 0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a};
    uchar ciphertextA2[16] = {0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9, 0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1};
    vector<uchar> cipherA1;

    vector<uchar> test;

    for (int i = 0; i < 16; i++) {
        test.push_back(klartextA1[i]);
        cipherA1.push_back(ciphertextA1[i]);
    }

    for (int i = 0; i < 16; i++) {
        test.push_back(klartextA2[i]);
        cipherA1.push_back(ciphertextA2[i]);
    }

    myCBC cbcA;
    cbcA.setKey(keyA);
    cbcA.setIV(ivA);
    cbcA.setKlartext(test);
    cbcA.crypt(false);

    //Prüfung
    bool isWorking = areEqual(cbcA.getCiphertext(), cipherA1) && areEqual(cbcB.getCiphertext(), cipherB1);

    if (isWorking) {
        returnValue = true;
    } else {
        returnValue = false;
    }
    return returnValue;
}

bool myGUI::checkECB() {
    bool returnValue = false;

    //16 Byte Testvektoren
    uchar schluessel[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};

    uchar klartext_1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar klartext_2[16] = {0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51};
    uchar klartext_3[16] = {0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef};

    uchar cipher_1[16] = {0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60, 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97};
    uchar cipher_2[16] = {0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d, 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf};
    uchar cipher_3[16] = {0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23, 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88};
    vector<uchar> cipherB1;
    vector<uchar> ktB;

    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_1[i]);
        cipherB1.push_back(cipher_1[i]);
    }

    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_2[i]);
        cipherB1.push_back(cipher_2[i]);
    }

    for (int i = 0; i < 16; i++) {
        ktB.push_back(klartext_3[i]);
        cipherB1.push_back(cipher_3[i]);
    }

    myECB ecb;
    ecb.setKey(schluessel);
    ecb.setKlartext(ktB);
    ecb.crypt(false);

    //Prüfung
    bool isWorking = areEqual(ecb.getCiphertext(), cipherB1);

    if (isWorking) {
        returnValue = true;
    } else {
        returnValue = false;
    }
    return returnValue;
}

bool myGUI::checkAES() {

    bool returnValue = false;
    uchar schluessel[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};

    uchar klartext_1[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
    uchar klartext_2[16] = {0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51};
    uchar klartext_3[16] = {0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef};

    uchar cipher_1[16] = {0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60, 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97};
    uchar cipher_2[16] = {0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d, 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf};
    uchar cipher_3[16] = {0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23, 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88};

    myAES aes1;
    aes1.setKlartext(klartext_1);
    aes1.setSchluessel(schluessel);
    aes1.crypt(false);

    myAES aes2;
    aes2.setKlartext(klartext_2);
    aes2.setSchluessel(schluessel);
    aes2.crypt(false);

    myAES aes3;
    aes3.setKlartext(klartext_3);
    aes3.setSchluessel(schluessel);
    aes3.crypt(false);

    bool isWorking = areEqual(aes3.getCiphertext(), cipher_3) && areEqual(aes2.getCiphertext(), cipher_2) && areEqual(aes1.getCiphertext(), cipher_1);
    if (isWorking) {
        returnValue = true;
    } else {

        returnValue = false;
    }
    return returnValue;
}

void myGUI::callAES() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    myAES aes;
    aes.crypt(false);
    //myAES aesDecrypt;
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 5;
    int input = end;

    //Menu Eingabe
    while (run) {
        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Text und Schluessel aus Datei laden\n";
        cout << "(4) Entschluesseln \n";
        cout << "(5) Zurueck\n";
        cout << "> ";
        input = validatedInput(lowest, end);
        if (input == 1) {
            aes.crypt(true);
        }
        if (input == 2) {
            aes.enterKlartext();
            aes.enterSchluessel();
            aes.crypt(true);
        }
        if (input == 3) {
            cerr << RED_start << "Noch nicht implementiert\n" << RED_end;
        }
        if (input == 4) {
            aes.decrypt(true);
        }
        if (input == 5) {
            run = false;
        }
        if (input == -1) {

            cerr << RED_start << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n" << RED_end;
            cout << endl;
        }
    }
}

void myGUI::callCBC() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    myCBC cbc;
    cbc.crypt(true);
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 5;
    int input = end;

    //Menu Eingabe
    while (run) {

        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Text und Schluessel aus Datei laden\n";
        cout << "(4) Text entschluesseln\n";
        cout << "(5) Zurueck\n";
        cout << "> ";
        input = validatedInput(lowest, end);
        if (input == 1) {
            cbc.crypt(true);
        }
        if (input == 2) {
            cbc.enterIV();
            cbc.enterKey();
            cbc.enterKlartext();
            cbc.crypt(true);
        }
        if (input == 3) {
            cerr << RED_start << "Noch nicht implementiert\n" << RED_end;
        }
        if (input == 4) {
            cbc.decrypt(true);
        }
        if (input == 5) {
            run = false;
        }
        if (input == -1) {
            cerr << RED_start << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n" << RED_end;
            cout << endl;
        }
    }

}

void myGUI::callECB() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    myECB ecb;
    ecb.crypt(false);
    bool run = true;
    unsigned int lowest = 1;
    unsigned int end = 5;
    int input = end;

    //Menu Eingabe
    while (run) {

        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) Text verschluesseln \n";
        cout << "(2) Text und Schluessel eingeben \n";
        cout << "(3) Text und Schluessel aus Datei laden\n";
        cout << "(4) Text entschluesseln\n";
        cout << "(5) Zurueck\n";
        cout << "> ";
        input = validatedInput(lowest, end);
        if (input == 1) {
            ecb.crypt(true);
        }
        if (input == 2) {
            ecb.enterKey();
            ecb.enterKlartext();
            ecb.crypt(true);
        }
        if (input == 3) {
            cerr << RED_start << "Noch nicht implementiert\n" << RED_end;
        }
        if (input == 4) {
                ecb.decrypt(true);
        }
        if (input == 5) {
            run = false;
        }
        if (input == -1) {
            cerr << RED_start << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n" << RED_end;
            cout << endl;
        }
    }

}

int myGUI::validatedInput(unsigned int lowest, unsigned int highest) {
    int tmp = 0;
    cin.clear();
    if (cin >> tmp) {//Eingabe ist in Ordnung
        cout << endl;
        if (tmp >= lowest && tmp <= highest) {//Eingabe liegt in den Parametern

            return tmp;
        }
    } else {
        string trash = "";
        cin.clear();
        std::getline(std::cin, trash);
    }
    return -1;
}

myGUI::myGUI() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    //Menu-Variablen

    unsigned int lowest = 1;
    unsigned int end = 4;
    int input = end;
    bool run = true;

    //Start
    cout << "#### Kryptographie Sommersemester 2013 ####\n";
    cout << "Nils Rogmann (725915) und Maximilian Krieg (725922)\n";

    // Begrüßung und Information
    cout << "\nHerzlich willkommen.\n";
    cout << "Das Programm wird nun mit Hilfe von Testvektoren geprüft.\n";

    // AES Check
    cout << "\nAES:\t\t";
    if (checkAES()) {
        cout << GREEN_start << "OK" << GREEN_end;
    } else {
        cerr << RED_start << "Fehler" << RED_end;
    }

    // CBC Check
    cout << "\nAES mit CBC:\t";
    if (checkCBC()) {
        cout << GREEN_start << "OK" << GREEN_end;
    } else {
        cerr << RED_start << "Fehler" << RED_end;
    }


    // ECB Check
    cout << "\nAES mit ECB:\t";
    if (checkECB()) 
    {
        cout << GREEN_start << "OK" << GREEN_end;
    }
    else
    {
        cerr << RED_start << "Fehler" << RED_end;
    }
    cout << endl;

    //Menu Eingabe
    while (run) {
        cout << "\nBitte waehlen sie aus:\n";
        cout << "(1) AES\n";
        cout << "(2) AES mit CBC\n";
        cout << "(3) AES mit ECB\n";
        cout << "(4) Programm beenden\n";
        cout << "> ";

        input = validatedInput(lowest, end);

        // Aufrufe
        if (input == 1) {
            cout << GREEN_start << "#### AES ####\n" << GREEN_end;
            callAES();
            cout << endl;
        }

        if (input == 2) {
            cout << GREEN_start << "#### AES mit CBC ####\n" << GREEN_end;
            callCBC();
            cout << endl;
        }


        if (input == 3) {
            cout << GREEN_start << "#### AES mit ECB ####\n" << GREEN_end;
            callECB();
            cout << endl;
        }

        // Fehler
        if (input == -1) {
            cerr << RED_start << "Ungueltige Eingabe getätigt.\nBitte nochmal eingeben.\n" << RED_end;
            cout << endl;
        }

        // Beenden
        if (input == end) {

            cout << "Programm wird beendet.\n";
            run = false;
            cout << endl;
        }
    }
}

myGUI::~myGUI() {
}

myAES.h

#ifndef MYAES_H
#define	MYAES_H

#include <iostream>

using namespace std;
// Typedefs
typedef unsigned char uchar;

class myAES {
public:
    // Konstruktoren/Destruktoren
    myAES();
    virtual ~myAES();

    // Manuelle Eingabe
    void enterKlartext();
    void enterSchluessel();

    // Set/Get-Methoden
    void setKlartext(uchar[16]);
    void setSchluessel(uchar[16]);
    void setCiphertext(uchar[16]);
    uchar* getKlartext();
    uchar* getSchluessel();
    uchar* getCiphertext();

    // AES-Methoden
    void crypt(bool);
    void mixcolumns();
    void shiftrows();
    void schluesselexpansion(uchar[][44], int, int, int);
    void rotword(uchar[], int);
    uchar mix(uchar, unsigned int);
    void subbytes(uchar [], uchar [], int);

    // Print-Methoden
    void printSchluessel();
    void printCiphertext();
    void printKlartext();
    
   void decrypt(bool) ;
   uchar gmul(uchar, uchar);
   void invert_mixcolumns();
   void invert_shiftrows();

private:
    uchar klartext[16];
    uchar schluessel[16];
    uchar ciphertext[16];
};



#endif	/* MYAES_H */

myAES.cpp

#include "myAES.h"

using namespace std;

unsigned char Sbox[256] = {//  s-box
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};

unsigned char sbox_inverse[256] = {
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};

unsigned char Rcon[256] = {
    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
    0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
    0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
    0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
    0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
    0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
    0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
    0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
    0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
    0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
    0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
    0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
    0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
    0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
    0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
};

void myAES::subbytes(uchar sbox[], uchar tmp[], int arrSize) {
    for (int i = 0; i < arrSize; i++) {
        tmp[i] = sbox[tmp[i]];
    }
}// subbytes

uchar myAES::mix(uchar byte, unsigned int mixvalue) {
    unsigned char retValue;
    switch (mixvalue) {
        case 1:
            retValue = byte;
            break;
        case 2:
            retValue = byte << 1;
            if (byte & 0x80) {
                retValue = retValue ^ 0x1b;
            }
            break;
        case 3:
            retValue = byte << 1;
            if (byte & 0x80) {
                retValue = retValue ^ 0x1b;
            }
            retValue = retValue^byte;
            break;
    }
    return retValue;
}

void addRoundKey(uchar klartext[], int iLaenge, uchar matrix[][44], int iReihe, int iSpalte, int iRunde) {
    int pos = 0;
    for (int i = iRunde * 4; i < ((iRunde * 4) + 4) && i < iSpalte; i++) {
        for (int k = 0; k < iReihe; k++) {
            klartext[pos] = klartext[pos] ^ matrix[k][i];
            pos++;
        }
    }
}// addroundkey

void myAES::rotword(uchar column[], int iReihe) {
    uchar tmp = column[0];
    for (int i = 1; i < iReihe; i++) {
        column[i - 1] = column[i];
    }
    column[iReihe - 1] = tmp;
} // rotword

void myAES::schluesselexpansion(uchar matrix[][44], int iReihe, int iSpalte, int iLaenge) {
    // Alle Spalten durchlaufen
    int pos = 0;

    for (int i = 0; i < iSpalte; i++) {
        if (i < 4) { // Schluessel in erste vier Spalten kopieren
            for (int k = 0; k < iReihe && pos < iLaenge; k++) {
                matrix[k][i] = schluessel[pos];
                pos++;
                //cout << hex << "matrix[" << k << "][" << i << "] = " << (int) matrix[k][i] << endl;
            }
        } else { // i > 4
            if (i % 4 == 0) {// erste Spalte eines Schluessels
                // Spalte in Hilfsarray kopieren
                uchar tmp[iReihe]; // i-1
                uchar tmp2[iReihe]; // i-4
                for (int k = 0; k < iReihe; k++) {
                    tmp[k] = matrix[k][i - 1];
                    tmp2[k] = matrix[k][i - 4];
                }

                rotword(tmp, iReihe);

                subbytes(Sbox, tmp, iReihe);

                // Spalte[i-4] XOR subbytes[rotword[i-i]
                for (int k = 0; k < iReihe; k++) {
                    tmp[k] = tmp[k] ^ tmp2[k];
                }

                // tmp[0] XOR (i/4)
                tmp[0] = tmp[0] ^ Rcon[i / iReihe];

                // tmp[k] an Spalte[k][i] kopieren
                for (int k = 0; k < iReihe; k++) {
                    matrix[k][i] = tmp[k];
                }

            } else {
                //cout << "i " << i << endl;
                for (int k = 0; k < iReihe; k++) {
                    matrix[k][i] = matrix[k][i - 4] ^ matrix[k][i - 1];
                }
            }
        }
    }
}// schluesselexpansion

void myAES::shiftrows() {
    uchar copys[16] = {};

    //reihe 1   
    copys[0] = ciphertext[0];
    copys[4] = ciphertext[4];
    copys[8] = ciphertext[8];
    copys[12] = ciphertext[12];

    //reihe 2
    copys[1] = ciphertext[5];
    copys[5] = ciphertext[9];
    copys[9] = ciphertext[13];
    copys[13] = ciphertext[1];

    // reihe 3
    copys[2] = ciphertext[10];
    copys[6] = ciphertext[14];
    copys[10] = ciphertext[2];
    copys[14] = ciphertext[6];

    //reihe 4
    copys[3] = ciphertext[15];
    copys[7] = ciphertext[3];
    copys[11] = ciphertext[7];
    copys[15] = ciphertext[11];

    //umschreiben   
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = copys[i];
    }
}// shiftrows

void myAES::mixcolumns() {
    for (int i = 0; i < 4; i++) {
        uchar sj0 = mix(ciphertext[i * 4], 2)^mix(ciphertext[i * 4 + 1], 3)^mix(ciphertext[i * 4 + 2], 1)^mix(ciphertext[i * 4 + 3], 1);
        uchar sj1 = mix(ciphertext[i * 4], 1)^mix(ciphertext[i * 4 + 1], 2)^mix(ciphertext[i * 4 + 2], 3)^mix(ciphertext[i * 4 + 3], 1);
        uchar sj2 = mix(ciphertext[i * 4], 1)^mix(ciphertext[i * 4 + 1], 1)^mix(ciphertext[i * 4 + 2], 2)^mix(ciphertext[i * 4 + 3], 3);
        uchar sj3 = mix(ciphertext[i * 4], 3)^mix(ciphertext[i * 4 + 1], 1)^mix(ciphertext[i * 4 + 2], 1)^mix(ciphertext[i * 4 + 3], 2);
        ciphertext[i * 4] = sj0;
        ciphertext[i * 4 + 1] = sj1;
        ciphertext[i * 4 + 2] = sj2;
        ciphertext[i * 4 + 3] = sj3;
    }
}// mixcolumns

void myAES::crypt(bool output) {

    // Parameter
    int iRunde = 10;
    int iLaenge = 16;

    // Überschreibe ciphertext um diesen fortan zu verwenden
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = klartext[i];
    }

    // Arraygroesse dynamisch bestimmen
    int arrSize = sizeof (ciphertext) / sizeof (ciphertext[0]);

    // Zwischenspeicherung der Rundenschluessel
    int iReihe = 4;
    int iSpalte = 4 * (iRunde + 1);
    uchar carrRundenschluessel[4][44];

    // Schluessel expandieren
    schluesselexpansion(carrRundenschluessel, iReihe, iSpalte, iLaenge);

    // Vorrunde
    for (int k = 0; k < iLaenge; k++) {
        ciphertext[k] = ciphertext[k] ^ schluessel[k];
    }

    // Durchlaufen der Runden
    for (int i = 1; i < iRunde + 1; i++) {

        // S-Box
        subbytes(Sbox, ciphertext, arrSize);

        // Shift Rows
        shiftrows();

        // Mix Columns
        if (i != (iRunde)) { // kein MixColumns in der letzten Runde
            mixcolumns();
        }

        // Rundenschlüssel addieren
        addRoundKey(ciphertext, arrSize, carrRundenschluessel, iReihe, iSpalte, i);

    }

    // Ausgabe des Ciphertexts
    if (output) {
        printSchluessel();
        printKlartext();
        printCiphertext();
    }
}

void myAES::invert_shiftrows() {
    uchar copys[16] = {};

    //reihe 1   
    copys[0] = klartext[0];
    copys[4] = klartext[4];
    copys[8] = klartext[8];
    copys[12] = klartext[12];

    //reihe 2
    copys[1] = klartext[13];
    copys[13] = klartext[9];
    copys[9] = klartext[5];
    copys[5] = klartext[1];

    // reihe 3   
    copys[6] = klartext[14];
    copys[2] = klartext[10];
    copys[14] = klartext[6];
    copys[10] = klartext[2];

    //reihe 4
    copys[11] = klartext[15];
    copys[7] = klartext[11];
    copys[3] = klartext[7];
    copys[15] = klartext[3];

    //umschreiben   
    for (int i = 0; i < 16; i++) {
        klartext[i] = copys[i];
    }
}// invert_shiftrows

void myAES::invert_mixcolumns() {
    for (int i = 0; i < 4; i++) {
        uchar sj0 = gmul(klartext[i * 4], 14)^gmul(klartext[i * 4 + 1], 11)^gmul(klartext[i * 4 + 2], 13)^gmul(klartext[i * 4 + 3], 9);
        uchar sj1 = gmul(klartext[i * 4], 9)^gmul(klartext[i * 4 + 1], 14)^gmul(klartext[i * 4 + 2], 11)^gmul(klartext[i * 4 + 3], 13);
        uchar sj2 = gmul(klartext[i * 4], 13)^gmul(klartext[i * 4 + 1], 9)^gmul(klartext[i * 4 + 2], 14)^gmul(klartext[i * 4 + 3], 11);
        uchar sj3 = gmul(klartext[i * 4], 11)^gmul(klartext[i * 4 + 1], 13)^gmul(klartext[i * 4 + 2], 9)^gmul(klartext[i * 4 + 3], 14);
        klartext[i * 4] = sj0;
        klartext[i * 4 + 1] = sj1;
        klartext[i * 4 + 2] = sj2;
        klartext[i * 4 + 3] = sj3;
    }
}

uchar myAES::gmul(uchar a, uchar b) {
    unsigned char p = 0;
    unsigned char hi;

    for (int i = 0; i < 8; ++i) {
        if ((b & 1) == 1)
            p ^= a;
        hi = (a & 0x80);
        a <<= 1;
        if (hi == 0x80)
            a ^= 0x1b;
        b >>= 1;
    }
    return p;
}

void myAES::decrypt(bool output) {

    // Parameter
    int iRunde = 10;
    int iLaenge = 16;


    // Überschreibe klartext um diesen fortan zu verwenden
    for (int i = 0; i < 16; i++) {
        klartext[i] = ciphertext[i];
    }


    // Arraygroesse dynamisch bestimmen
    int arrSize = sizeof (klartext) / sizeof (klartext[0]);

    // Zwischenspeicherung der Rundenschluessel
    int iReihe = 4;
    int iSpalte = 4 * (iRunde + 1);
    uchar carrRundenschluessel[4][44];

    // Schluessel expandieren
    schluesselexpansion(carrRundenschluessel, iReihe, iSpalte, iLaenge);

    //printRundenSchluessel(carrRundenschluessel, iReihe, iSpalte);

    // "neue" Vorrunde
    addRoundKey(klartext, arrSize, carrRundenschluessel, iReihe, iSpalte, 10);

    // Durchlaufen der Runden
    for (int i = 9; i > 0; i--) {

        // Shift Rows
        invert_shiftrows();

        // S-Box
        subbytes(sbox_inverse, klartext, arrSize);

        // Rundenschlüssel addieren
        addRoundKey(klartext, arrSize, carrRundenschluessel, iReihe, iSpalte, i);

        // Mix Columns
        if (i != 10) { // kein MixColumns in der letzten Runde
            invert_mixcolumns();
        }
    }


    // Letzte Runde
    invert_shiftrows();
    subbytes(sbox_inverse, klartext, arrSize);

    for (int k = 0; k < iLaenge; k++) {
        klartext[k] = klartext[k] ^ schluessel[k];
    }

    // Ausgabe des Ciphertexts
    if (output) {
        printSchluessel();
        printCiphertext();
        printKlartext();
    }
}// decrypt

void myAES::printSchluessel() {
    cout << endl << "Schluessel:\n";
    for (int i = 0; i < 4; i++)
        cout << hex << "\t0x" << (int) schluessel[0 + i] << "\t0x" << (int) schluessel [4 + i] << "\t0x" << (int) schluessel [8 + i] << "\t0x" << (int) schluessel[12 + i] << endl;
    cout << endl;
}

void myAES::printCiphertext() {
    cout << endl << "Ciphertext:\n";
    for (int i = 0; i < 4; i++)
        cout << hex << "\t0x" << (int) ciphertext[0 + i] << "\t0x" << (int) ciphertext [4 + i] << "\t0x" << (int) ciphertext [8 + i] << "\t0x" << (int) ciphertext[12 + i] << endl;
    cout << endl;
}

void myAES::printKlartext() {
    cout << endl << "Klartext:\n";
    for (int i = 0; i < 4; i++)
        cout << hex << "\t0x" << (int) klartext[0 + i] << "\t0x" << (int) klartext [4 + i] << "\t0x" << (int) klartext [8 + i] << "\t0x" << (int) klartext[12 + i] << endl;
    cout << endl;
}

myAES::myAES() {
    uchar kt[16] = {0x61, 0x62, 0x62, 0x69, 0x6c, 0x64, 0x75, 0x6e, 0x67, 0x73, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78};
    uchar s[16] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31};
    //uchar c[16] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31};
    for (int i = 0; i < 16; i++) {
        schluessel[i] = s[i];
        klartext[i] = kt[i];
    }
}

myAES::~myAES() {
}

void myAES::enterKlartext() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    string tmp = "";
    int diff = 0;
    cout << "Klartext (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << RED_start << "\nWerte fuer den Klartext zu groß. Trenne nach 16 Zeichen ab.\n(" << GREEN_start;
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << RED_start << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << RED_end << endl;
        }

        if (tmp.length() < 16) {
            cerr << RED_start << "\nWert fuer den Klartext zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << RED_end << endl;
        }

        for (int i = 0; i < 16; i++) {
            klartext[i] = tmp[i];
        }
        cout << endl;

    }
}

void myAES::enterSchluessel() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    string tmp = "";
    int diff = 0;
    cout << "Schluessel (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << RED_start << "\nWerte fuer den Schluessel zu groß. Trenne nach 16 Zeichen ab.\n(" << GREEN_start;
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << RED_start << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << RED_end << endl;
        }

        if (tmp.length() < 16) {
            cerr << RED_start << "\nWert fuer den Schluessel zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << RED_end << endl;
        }

        for (int i = 0; i < 16; i++) {
            schluessel[i] = tmp[i];
            //cout << hex << tmp[i];
        }
        cout << endl;

    }
}

void myAES::setCiphertext(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        ciphertext[i] = tmp[i];
    }

}

void myAES::setKlartext(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        klartext[i] = tmp[i];
    }
}

void myAES::setSchluessel(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        schluessel[i] = tmp[i];

    }
}

uchar* myAES::getSchluessel() {
    return schluessel;
}

uchar* myAES::getCiphertext() {
    return ciphertext;
}

uchar* myAES::getKlartext() {
    return klartext;
}

myCBC.h

#ifndef MYCBC_H
#define	MYCBC_H
#include "myAES.h"
#include <vector>
class myCBC {
public:
    // Konstruktoren / Destruktoren
    myCBC();
    virtual ~myCBC();
    
    //CBC
    void crypt(bool);
    void decrypt(bool);
    
    // Set/Get-Methoden
    void setKey(uchar[16]);
    void setIV(uchar[16]);
    void setKlartext(vector<uchar>);
    void setCiphertext(vector<uchar>);

    vector<uchar> getKlartext();
    vector<uchar> getCiphertext();
    uchar* getSchluessel();
    uchar* getIV();
    
    // Manuelle Eingabe
    void enterKey();
    void enterIV();
    void enterKlartext();
    
    // Print-Methoden
    void printSchluessel();
    void printCiphertext();
    void printKlartext();
    
private:
    //unsigned int stellen;
    uchar iv[16];
    uchar key[16];
    vector<uchar> klartext;
    vector<uchar> ciphertext;

};

#endif	/* MYCBC_H */

myCBC.cpp

#include "myCBC.h"

void myCBC::enterKey() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    string tmp = "";
    int diff = 0;
    cout << "Schluessel (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << RED_start << "\nWerte fuer den Schluessel zu groß. Trenne nach 16 Zeichen ab.\n(" << GREEN_start;
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << RED_start << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << RED_end << endl;
        }

        if (tmp.length() < 16) {
            cerr << RED_start << "\nWert fuer den Schluessel zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << RED_end << endl;
        }

        for (int i = 0; i < 16; i++) {
            key[i] = tmp[i];
        }
        cout << endl;

    }
}

void myCBC::enterIV() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    string tmp = "";
    int diff = 0;
    cout << "IV (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << RED_start << "\nWerte fuer den IV zu groß. Trenne nach 16 Zeichen ab.\n(" << GREEN_start;
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << RED_start << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << RED_end << endl;
        }

        if (tmp.length() < 16) {
            cerr << RED_start << "\nWert fuer den IV zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << RED_end << endl;
        }

        for (int i = 0; i < 16; i++) {
            iv[i] = tmp[i];
        }
        cout << endl;

    }
}

void myCBC::enterKlartext() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    klartext.clear();
    string tmp = "";
    cout << "Klartext (Beliebig viele Zeichen):";
    if (cin >> tmp) {
        for (int i = 0; i < tmp.size(); i++) {
            klartext.push_back(tmp[i]);
        }
        cout << endl;
    }

    if (tmp.size() % 16 != 0) {
        cerr << RED_start << "\nLetzter Klartext-Block nicht vollstaendig. Fuelle mit Nullen auf.\n";
        for (int i = 0; i < 16 - tmp.size() % 16; i++) {
            klartext.push_back('\0');
        }
        cout << RED_end << endl;
    }
}

myCBC::myCBC() {

    // Default Parameter
    uchar newKey[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar newIV[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    uchar newKlartext[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};

    // Schluessel setzen
    for (int i = 0; i < 16; i++) {
        key[i] = newKey[i];
    }

    //IV setzen
    for (int i = 0; i < 16; i++) {
        iv[i] = newIV[i];
    }

    // Klartext setzen
    for (int i = 0; i < 16; i++) {
        klartext.push_back(newKlartext[i]);
    }
}

void myCBC::printSchluessel() {
    cout << endl << "Schluessel:\n";
    for (int i = 0; i < 4; i++)
        cout << hex << "\t0x" << (int) key[0 + i] << "\t0x" << (int) key [4 + i] << "\t0x" << (int) key [8 + i] << "\t0x" << (int) key[12 + i] << endl;
    cout << endl;
}

void myCBC::printCiphertext() {
    cout << endl << "Ciphertext:\n";
    for (int i = 0; i < ciphertext.size(); i++) {
        cout << std::hex << " 0x" << (int) ciphertext[i];
    }
}

void myCBC::printKlartext() {
    cout << endl << "Klartext:\n";
    for (int i = 0; i < klartext.size(); i++) {
        cout << std::hex << " 0x" << (int) klartext[i];
    }
}

vector<uchar> myCBC::getCiphertext() {
    return ciphertext;
}

void myCBC::decrypt(bool print) {
    klartext.clear();
    uchar tmp_iv[16];
    for (int j = 0; j < 16; j++) {
        tmp_iv[j] = iv[j];
    }
    //printSchluessel();
    //printKlartext();
    //printCiphertext();
    for (int i = 0; i < ciphertext.size() / 16; i++) {

        myAES a1;

        //Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = ciphertext[j + 16 * i];
        }

        // Ciphertext
        a1.setCiphertext(tmp);

        // Schluessel
        a1.setSchluessel(key);

        // crypt
        a1.decrypt(false);

        // Resultat mit IV addieren
        for (int j = 0; j < 16; j++) {

            a1.getKlartext()[j] = a1.getKlartext()[j]^tmp_iv[j];
        }

        for (int j = 0; j < 16; j++) {
            tmp_iv[j] = a1.getCiphertext()[j + 16 * i];
            klartext.push_back(a1.getKlartext()[j]);
        }
    }

    if (print) {
        printSchluessel();
        printCiphertext();
        printKlartext();
    }

}

void myCBC::crypt(bool print) {
    ciphertext.clear();
    uchar tmp_iv[16];
    for (int i = 0; i < 16; i++) {
        tmp_iv[i] = iv[i];
    }

    for (int i = 0; i < klartext.size() / 16; i++) {

        myAES a1;
        a1.setSchluessel(key);

        //XOR in Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = klartext[j + 16 * i]^tmp_iv[j];
        }

        // Klartext
        a1.setKlartext(tmp);

        // crypt
        a1.crypt(false);


        for (int j = 0; j < 16; j++) {
            tmp_iv[j] = a1.getCiphertext()[j];
            ciphertext.push_back(a1.getCiphertext()[j]);
        }
    }

    if (print) {
        printSchluessel();
        printKlartext();
        printCiphertext();
    }
}

void myCBC::setKlartext(vector<uchar> kt) {
    if (kt.size() > klartext.size()) {
        int diff = kt.size() - klartext.size();
        for (int i = 0; i < diff; i++) {
            klartext.push_back(0x00);
        }
    }
    for (int i = 0; i < kt.size(); i++) {
        klartext.at(i) = kt.at(i);
    }
}

void myCBC::setIV(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        iv[i] = tmp[i];
    }
}

void myCBC::setKey(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        key[i] = tmp[i];
    }
}

myCBC::~myCBC() {
}

myECB.h

#ifndef MYECB_H
#define	MYECB_H

#include "myAES.h"
#include <vector>
class myECB {
public:
    // Konstruktoren / Destruktoren
    myECB();
    virtual ~myECB();
    
    //CBC
    void crypt(bool);
    void decrypt(bool);
    
    // Set/Get-Methoden
    void setKey(uchar[16]);
    
    void setKlartext(vector<uchar>);
    void setCiphertext(vector<uchar>);

    vector<uchar> getKlartext();
    vector<uchar> getCiphertext();
    uchar* getSchluessel();
    
    
    // Manuelle Eingabe
    void enterKey();
    
    void enterKlartext();
    
    // Print-Methoden
    void printSchluessel();
    void printCiphertext();
    void printKlartext();
    
private:
    //unsigned int stellen;
    
    uchar key[16];
    vector<uchar> klartext;
    vector<uchar> ciphertext;

};

#endif	/* MYECB_H */

myECB.cpp

#include "myECB.h"

void myECB::enterKey() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    string GREEN_start = "\033[22;32m";
    string GREEN_end = "\033[0m";
    string tmp = "";
    int diff = 0;
    cout << "Schluessel (16 Zeichen):";
    if (cin >> tmp) {

        if (tmp.length() > 16) {
            cerr << RED_start << "\nWerte fuer den Schluessel zu groß. Trenne nach 16 Zeichen ab.\n(" << GREEN_start;
            for (int i = 0; i < tmp.length(); i++) {
                if (i == 16) {
                    cerr << RED_start << " | ";
                }
                cerr << tmp.at(i);
            }
            cout << ")" << RED_end << endl;
        }

        if (tmp.length() < 16) {
            cerr << RED_start << "\nWert fuer den Schluessel zu klein. Fuelle mit Nullen auf.\n";
            diff = 16 - tmp.length();
            for (int i = 0; i < diff; i++) {
                tmp.push_back('\0');
            }
            cout << RED_end << endl;
        }

        for (int i = 0; i < 16; i++) {
            key[i] = tmp[i];
        }
        cout << endl;

    }
}

void myECB::enterKlartext() {
    string RED_start = "\033[22;31m";
    string RED_end = "\033[0m";
    klartext.clear();
    string tmp = "";
    cout << "Klartext (Beliebig viele Zeichen):";
    if (cin >> tmp) {
        for (int i = 0; i < tmp.size(); i++) {
            klartext.push_back(tmp[i]);
        }
        cout << endl;
    }

    if (tmp.size() % 16 != 0) {
        cerr << RED_start << "\nLetzter Klartext-Block nicht vollstaendig. Fuelle mit Nullen auf.\n";
        for (int i = 0; i < 16 - tmp.size() % 16; i++) {
            klartext.push_back('\0');
        }
        cout << RED_end << endl;
    }
}

myECB::myECB() {

    // Default Parameter
    uchar newKey[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uchar newIV[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    uchar newKlartext[16] = {0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};

    // Schluessel setzen
    for (int i = 0; i < 16; i++) {
        key[i] = newKey[i];
    }

    // Klartext setzen
    for (int i = 0; i < 16; i++) {
        klartext.push_back(newKlartext[i]);
    }
}

void myECB::printSchluessel() {
    cout << endl << "Schluessel:\n";
    for (int i = 0; i < 4; i++)
        cout << hex << "\t0x" << (int) key[0 + i] << "\t0x" << (int) key [4 + i] << "\t0x" << (int) key [8 + i] << "\t0x" << (int) key[12 + i] << endl;
    cout << endl;
}

void myECB::printCiphertext() {
    cout << endl << "Ciphertext:\n";
    for (int i = 0; i < ciphertext.size(); i++) {
        cout << std::hex << " 0x" << (int) ciphertext[i];
    }
}

void myECB::printKlartext() {
    cout << endl << "Klartext:\n";
    for (int i = 0; i < klartext.size(); i++) {
        cout << std::hex << " 0x" << (int) klartext[i];
    }
}

vector<uchar> myECB::getCiphertext() {
    return ciphertext;
}

void myECB::decrypt(bool print) {
    klartext.clear();

    for (int i = 0; i < ciphertext.size() / 16; i++) {

        myAES a1;

        //Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = ciphertext[j + 16 * i];
        }

        // Ciphertext
        a1.setCiphertext(tmp);

        // Schluessel
        a1.setSchluessel(key);

        // crypt
        a1.decrypt(false);

        // Resultat mit IV addieren
        for (int j = 0; j < 16; j++) {
            klartext.push_back(a1.getKlartext()[j]);
        }
    }

    if (print) {
        printSchluessel();
        printCiphertext();
        printKlartext();
    }

}

void myECB::crypt(bool print) {
    ciphertext.clear();
    /* uchar tmp_iv[16];
     for (int i = 0; i < 16; i++) {
         tmp_iv[i] = iv[i];
     }*/

    for (int i = 0; i < klartext.size() / 16; i++) {

        myAES a1;
        a1.setSchluessel(key);

        //XOR in Übergabe - Array
        uchar tmp[16];
        for (int j = 0; j < 16; j++) {
            tmp[j] = klartext[j + 16 * i]; //^tmp_iv[j];
        }

        // Klartext
        a1.setKlartext(tmp);

        // crypt
        a1.crypt(false);


        for (int j = 0; j < 16; j++) {
            //tmp_iv[j] = a1.getCiphertext()[j];
            ciphertext.push_back(a1.getCiphertext()[j]);
        }
    }

    if (print) {
        printSchluessel();
        printKlartext();
        printCiphertext();
    }
}

void myECB::setKlartext(vector<uchar> kt) {
    if (kt.size() > klartext.size()) {
        int diff = kt.size() - klartext.size();
        for (int i = 0; i < diff; i++) {
            klartext.push_back(0x00);
        }
    }
    for (int i = 0; i < kt.size(); i++) {
        klartext.at(i) = kt.at(i);
    }
}

void myECB::setKey(uchar tmp[16]) {
    for (int i = 0; i < 16; i++) {
        key[i] = tmp[i];
    }
}

myECB::~myECB() {
}

Der Beitrag Kryptologie (Praktikum 3) erschien zuerst auf Maximilian Krieg.