diff --git a/src/main/java/Enigma/Main.java b/src/main/java/Enigma/Main.java
index 53b9f3becf1ccb85df23add6b945f89a081ea878..2bfc594ce53b57275c180938447de3ea3a866f17 100644
--- a/src/main/java/Enigma/Main.java
+++ b/src/main/java/Enigma/Main.java
@@ -1,26 +1,14 @@
package Enigma;
-import Enigma.model.Funkraum;
+import Enigma.model.Codebuch;
+import Enigma.model.DatenbankSqlite;
+import Enigma.model.Morsecode;
-import java.io.IOException;
+import java.sql.SQLException;
public class Main {
- public static void main(String[] args) {
- Funkraum fr = new Funkraum();
- try {
- fr.sendeFunkspruch("Testen wir doch mal das ganze", "deisold");
- } catch (IOException e) {
- e.printStackTrace();
- }
- try {
- String[] funkspruch = fr.empfangeFunkspruch("deisold");
- System.out.println("Empfangen: " + funkspruch[0]);
- System.out.println("Nachricht: " + funkspruch[1]);
- } catch (IOException e) {
- e.printStackTrace();
- }
+ public static void main(String[] args) throws SQLException {
App.main(args);
}
-
}
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
index a257417737d8e0d29d3751fcfda8883a0f2e4b07..cf471ec284c4492866f8d9616c0de6adfcc956a1 100644
--- a/src/main/java/Enigma/model/Codebuch.java
+++ b/src/main/java/Enigma/model/Codebuch.java
@@ -5,7 +5,7 @@ package Enigma.model;
* Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
* Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
* mussten um die Texte zu ver/entschlüsseln.
- * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walzen gesetzt und deren Grundeinstellung
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
* vorgenommen.
* Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
* festgelegt war.
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/Enigma/model/DatenbankSqlite.java
index d065c5292e92500800aac22f828b6518c2bafb27..891c011a036f01b038400dbb808d65c11a0b8f43 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/Enigma/model/DatenbankSqlite.java
@@ -1,6 +1,8 @@
package Enigma.model;
+import javax.swing.text.html.HTML;
import java.sql.*;
+import java.util.Random;
/**
* Dies ist die SQLite Datenbank Klasse
@@ -60,4 +62,89 @@ public class DatenbankSqlite {
return cb;
}
+
+ //region Random New Codebuch generieren
+ /*
+ *//**
+ * Setzt zufällige Codebuch Einträge in die SQLite Datenbank
+ * Tag => int
+ * Walzenlage => String w1,w2,w3
+ * Ringstellung => String r1,r2,r3
+ * Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
+ *//*
+ public void autoGenCodebuch() throws SQLException {
+
+ Connection conn = connect();
+ conn.setAutoCommit(false);
+ PreparedStatement pstmtInsert = conn.prepareStatement("INSERT INTO table_codebuch (Tag, Walzenlage, Ringstellung, Steckverbindung) VALUES (?, ?, ?, ?);");
+ for (int i = 3; i < 32; i++) {
+ pstmtInsert.setInt(1, i);
+ pstmtInsert.setString(2, walzenlage());
+ pstmtInsert.setString(3, ringstellung());
+ pstmtInsert.setString(4, steckverbindung());
+ pstmtInsert.executeUpdate();
+ }
+
+ conn.commit();
+ }
+
+ *//**
+ * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
+ * die Zahlen sind durch Komma getrennt
+ * @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
+ *//*
+ private static String walzenlage(){
+ String walzenlage;
+ Random random = new Random();
+ int[] w = new int[3];
+ for (int i = 0; i < 3; i++) {
+
+ w[i] = (random.nextInt(5))+1;
+ if (i==1&&w[0]==w[i])w[i]=(random.nextInt(5))+1;
+ if ((i==2&&w[0]==w[2])||(i==2&&w[1]==w[i]))w[i]=(random.nextInt(5))+1;
+ }
+ walzenlage= w[0]+","+w[1]+","+w[2];
+ return walzenlage;
+ }
+
+ *//**
+ * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
+ * die Zahlen sind durch Komma getrennt
+ * @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
+ *//*
+ private static String ringstellung(){
+ String ringstellung;
+ Random random = new Random();
+ int[] w = new int[3];
+ for (int i = 0; i < 3; i++) {
+ w[i] = (random.nextInt(26))+1;
+ }
+ ringstellung= w[0]+","+w[1]+","+w[2];
+ return ringstellung;
+ }
+
+ *//**
+ * Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
+ * @return String => 10 Buchstabenkombinationen mit Komma getrennt
+ *//*
+ private static String steckverbindung(){
+ Random rnd = new Random();
+ String steckverbindung="";
+ char[] c = new char[2];
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 2; j++) {
+ c[j]= (char) (rnd.nextInt(26) + 'A');
+ if (j==1) {
+ while (c[0] == c[j]) {
+ c[j] = (char) (rnd.nextInt(26) + 'A');
+ }
+ }
+ }
+ System.out.println(c[0]+" / "+c[1]);
+ steckverbindung+= ((""+c[0]) + (""+c[1]) +",");
+ }
+ steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
+ return steckverbindung;
+ }*/
+ //endregion
}
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d72adc6bf887c4593b4c591b2aaf1c7eba020de
--- /dev/null
+++ b/src/main/java/Enigma/model/Walze.java
@@ -0,0 +1,224 @@
+package Enigma.model;
+
+public class Walze {
+
+ Character buchstabe = null;
+ Character ringstellung = null;
+ int walzennr = 0;
+ int iPositionBuchstabe = 0;
+ int iPositionBuchstabeRe = 0;
+ Character[] walze = new Character[25];
+
+ /**
+ * Gibt die Parameter der Walze mit
+ *
+ * @param walzennr : int : Nummer der gewaehlten Walze
+ * @param buchstabe : Character : Grundeinstellung der Walze
+ * @param ringstellung : Character : Einstellung des Notch
+ */
+ public Walze(int walzennr, Character buchstabe, Character ringstellung) {
+ this.walzennr = walzennr;
+ this.buchstabe = buchstabe;
+ this.ringstellung = ringstellung;
+ }
+
+ /**
+ * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+ */
+ public char getBuchstabe() {
+ return buchstabe;
+ }
+
+ /**
+ * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+ * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+ * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
+ *
+ * @param buchstabe : Character : Grundeinstellung der Walze
+ */
+ private void setBuchstabe(Character buchstabe) {
+ this.buchstabe.toUpperCase(buchstabe);
+
+ if(buchstabe.isLetter(buchstabe)) {
+ this.buchstabe = buchstabe;
+ } else {
+ this.buchstabe = 'A';
+ }
+
+ }
+
+ /**
+ * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+ */
+ public char getRingstellung() {
+ return ringstellung;
+ }
+
+
+ /**
+ * Gibt die Initiale Ringstellung der Walze an.
+ * Es sind nur Zahlen von 1 - 26 zugelassen.
+ * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+ *
+ * @param ringstellung : Character : Punkt an dem die Walze umspringt
+ */
+ private void setRingstellung(Character ringstellung) {
+
+ if(buchstabe.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
+ this.ringstellung = ringstellung;
+ } else {
+ this.ringstellung = '1';
+ }
+ }
+
+ /**
+ * @return walzennr : int : gibt die Walzennummer zurueck
+ */
+ public int getWalzennr() {
+ return walzennr;
+ }
+
+ /**
+ * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
+ *
+ * @param walzennr : int : setzt die Walzennummer
+ */
+ private void setWalzennr(int walzennr) {
+ if(walzennr > 0 && walzennr < 6) {
+ this.walzennr = walzennr;
+ } else {
+ System.err.println("Keine gültige Walzennummer");
+ }
+ }
+
+ /**
+ * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
+ *
+ * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+ */
+ private Character[] walzenNummer() {
+
+ //Walze nach der Cheffrierung
+ Character[] walzeEins = {'E','K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+ Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+ Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+ Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+ Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+ switch (getWalzennr()) {
+ case 1:
+ walze = walzeEins;
+ break;
+ case 2:
+ walze = walzeZwei;
+ break;
+ case 3:
+ walze = walzeDrei;
+ break;
+ case 4:
+ walze = walzeVier;
+ break;
+ case 5:
+ walze = walzeFuenf;
+ break;
+ }
+
+ return walze;
+ }
+
+ /**
+ * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
+ * der Cheffrierung auf der gewaehlten Walze abgleichen zu koennen.
+ *
+ * @return iPositionBuchstabe : int : Position des Buchstaben im Array
+ */
+ public int positionBuchstabe() {
+
+ //Alphabetswalze
+ Character[] walzeAlpha = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+ int index = 0;
+
+ //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+ for(index = 0; index < walzeAlpha.length; index++) {
+ if(buchstabe.equals(walzeAlpha[index])) {
+ iPositionBuchstabe = index;
+ break;
+ }
+ }
+
+ return iPositionBuchstabe;
+ }
+
+
+ /**
+ * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
+ * anhand der gewaehlten Walze.
+ *
+ * @param iPositionBuchstabe : int : Position des zu cheffrierenden Buchstabens
+ * @param walze : Character[] : ausgewaehlte Walze
+ * @return cheffrierterBuchstabe : Character : cheffrierter Buchstabe
+ */
+ public Character codierterBuchstabe(int iPositionBuchstabe, Character[] walze) {
+ Character codierterBuchstabe = walze[iPositionBuchstabe];
+ return codierterBuchstabe;
+ }
+
+
+ /**
+ * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
+ * erhoeht sie um eins.
+ * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
+ * Ab Position 25 wird wieder bei 0 angefangen.
+ *
+ * @param iPositionBuchstabe : int : alte Position der Walze
+ * @return iPositionBuchstabe : int : neue Position der Walze
+ */
+ public int vorstellenDerWalze(int iPositionBuchstabe) {
+
+ if(iPositionBuchstabe == 25) {
+ iPositionBuchstabe = 0;
+ } else {
+ iPositionBuchstabe += 1;
+ }
+
+ return iPositionBuchstabe;
+ }
+
+ /**
+ * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
+ * der Cheffrierung auf der AlphaWalze abgleichen zu koennen.
+ *
+ * @param walzennr : int : gibt die gewaehlte Walze zurueck
+ * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
+ */
+ public int positionBuchstabeReverse(int walzennr) {
+
+ int index = 0;
+
+ //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+ for(index = 0; index < walze.length; index++) {
+ if(buchstabe.equals(walze[index])) {
+ iPositionBuchstabeRe = index;
+ break;
+ }
+ }
+ return iPositionBuchstabeRe;
+ }
+
+ /**
+ * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+ * anhand der AlphaWalze.
+ *
+ * @param iPositionBuchstabeRe : int : Position des zu cheffrierenden Buchstabens
+ * @return codierterBuchstabeRe : Character : cheffrierter Buchstabe
+ */
+ public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
+ //Alphawalze
+ Character[] walzeAlpha = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+ Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
+ return codierterBuchstabeRe;
+ }
+
+}
diff --git a/src/main/resources/Enigma/codebuch.sqlite b/src/main/resources/Enigma/codebuch.sqlite
index 7d4a703b04d15e43146dddaca53c1b8e3ea83877..78be5227db85283c0c20e3719303cb77e48e8cbf 100644
Binary files a/src/main/resources/Enigma/codebuch.sqlite and b/src/main/resources/Enigma/codebuch.sqlite differ