init
This commit is contained in:
Felix Steghofer
252
Enigma/Shell.java
Normal file
252
Enigma/Shell.java
Normal file
@@ -0,0 +1,252 @@
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Main Class for interaction with the user.
|
||||
*
|
||||
*/
|
||||
public final class Shell {
|
||||
/**
|
||||
* number of arguments / rotor.
|
||||
*/
|
||||
private static final int ROTORARGS = 3;
|
||||
/**
|
||||
* Patchboard-permutation.
|
||||
*/
|
||||
private static final int[] PATCHBOARDPERMU = new int[] {9, 22, 20, 11, 2, 12
|
||||
, 13, 14, 7, 15, 16, 25, 24, 23, 8, 17, 0, 3, 10, 4, 6, 21, 1, 19
|
||||
, 18, 5};
|
||||
|
||||
/**
|
||||
* Reflector- permutation.
|
||||
*/
|
||||
private static final int[] REFLECTORPERMU = new int[] {8, 12, 4, 19, 2, 6, 5
|
||||
, 17, 0, 24, 18, 16, 1, 25, 23, 22, 11, 7, 10, 3, 21, 20, 15, 14
|
||||
, 9, 13};
|
||||
|
||||
/**
|
||||
* Amount of Symbols the alphabet uses.
|
||||
*/
|
||||
private static int symbols = PATCHBOARDPERMU.length;
|
||||
|
||||
private Shell() { }
|
||||
|
||||
/**
|
||||
* Convert char-Array to Enigma-permutation-array.
|
||||
* @param charArray char-array to convert
|
||||
* @return Enigma-compatible <code>permutation array</code>
|
||||
*/
|
||||
private static int[] convertCharInt(final char[] charArray) {
|
||||
int[] intArray = new int[charArray.length];
|
||||
for (int i = 0; i < charArray.length; i++) {
|
||||
intArray[i] = (charArray[i] - 65);
|
||||
}
|
||||
return intArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Enigma-int to char.
|
||||
* @param i Enigma-int
|
||||
* @return <code>char</code>
|
||||
*/
|
||||
private static char convertIntChar(final int i) {
|
||||
return (char) (i + 65);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if every Parameter for a Enigma exists.
|
||||
* @param stringArray Array of all programm parameters
|
||||
* @return <code>true</code> if right number of parameters are given<br />
|
||||
* <code>false</code> if wrong number of parameters or parameters
|
||||
* are zero
|
||||
*/
|
||||
private static boolean checkArgsLength(final String[] stringArray) {
|
||||
return stringArray.length % ROTORARGS == 0 && stringArray.length != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts the Permutation-Array Elements out of the Arguments
|
||||
* given by the User. <br /> Every third Element is a Permutation-Array.
|
||||
* Furthermore, the lengths of the Array is checked to handle faults.
|
||||
* @param stringAr the <code>String</code> entered by the user.
|
||||
* @return <code>Permutation-Array[][]</code> for every Rotor as a
|
||||
* char-array or<br /><code>null</code> if any error occurs.
|
||||
*/
|
||||
private static int[][] extractPermuArray(final String[] stringAr) {
|
||||
int[][] intArray = new int[(stringAr.length / ROTORARGS)]
|
||||
[Shell.symbols];
|
||||
for (int i = 0; i < (stringAr.length) / ROTORARGS; i++) {
|
||||
if (stringAr[(i * ROTORARGS)].length() == Shell.symbols) {
|
||||
intArray[i] = convertCharInt(
|
||||
stringAr[(i * ROTORARGS)].toCharArray());
|
||||
} else { return null; }
|
||||
}
|
||||
return intArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the tick-Positions out of string-array into a int-array.
|
||||
* @param stringAr All Arguments committed to the Programm
|
||||
* @return <code>int-array</code> with rotors tick-positions <br />
|
||||
* or <code>null</code> if tick-positition has more then
|
||||
* one character
|
||||
*/
|
||||
private static int[] extractTickPosArray(final String[] stringAr) {
|
||||
int[] intArray = new int[(stringAr.length / ROTORARGS)];
|
||||
for (int i = 0; i < (stringAr.length / ROTORARGS); i++) {
|
||||
if (stringAr[1 + (i * ROTORARGS)].toCharArray().length == 1) {
|
||||
intArray[i] = stringAr[1 + (i * ROTORARGS)].charAt(0) - 65;
|
||||
} else { return null; }
|
||||
}
|
||||
return intArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the initial-Positions out of string-array into a int-array.
|
||||
* @param stringAr All Arguments committed to the Programm
|
||||
* @return <code>int-array</code> with rotors initial-positions <br />
|
||||
* or <code>null</code> if initial-positition has more then
|
||||
* one character
|
||||
*/
|
||||
private static int[] extractInitialPosArray(final String[] stringAr) {
|
||||
int[] intArray = new int[(stringAr.length / ROTORARGS)];
|
||||
for (int i = 0; i < (stringAr.length / ROTORARGS); i++) {
|
||||
if (stringAr[2 + (i * ROTORARGS)].toCharArray().length == 1) {
|
||||
intArray[i] = stringAr[2 + (i * ROTORARGS)].charAt(0) - 65;
|
||||
} else { return null; }
|
||||
}
|
||||
return intArray;
|
||||
}
|
||||
/**
|
||||
* Checks if char is a capital-Letter.
|
||||
* @param ch Character
|
||||
* @return <code>true</code> <br >/
|
||||
* or <code>false</code>
|
||||
*/
|
||||
private static boolean isEnigmaChar(final int ch) {
|
||||
if (ch < 0 || ch >= Shell.symbols) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if char-array is a capital-Letter-array.
|
||||
* @param ch Character-array
|
||||
* @return <code>true</code> <br >/
|
||||
* or <code>false</code>
|
||||
*/
|
||||
private static boolean isEnigmaCharArray(final int[] ch) {
|
||||
for (int i = 0; i < ch.length; i++) {
|
||||
if (!isEnigmaChar(ch[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if char-array-array is a capital-Letter-array-array.
|
||||
* @param ch Character-array-array
|
||||
* @return <code>true</code> <br >/
|
||||
* or <code>false</code>
|
||||
*/
|
||||
private static boolean isEnigmaCharArray(final int[][] ch) {
|
||||
for (int i = 0; i < ch.length; i++) {
|
||||
if (!isEnigmaCharArray(ch[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
/**
|
||||
* Checks if a permutation contains a char twice.
|
||||
* @param permu Permutation
|
||||
* @return <code>true</code> if duplicate char is found<br />
|
||||
* <code>false</code> if chars are unique
|
||||
*/
|
||||
private static boolean hasDuplicateChar(final int[][] permu) {
|
||||
boolean[][] foo = new boolean[permu.length][permu[0].length];
|
||||
int i;
|
||||
int j;
|
||||
for (i = 0; i < permu.length; i++) {
|
||||
for (j = 0; j < permu[i].length; j++) {
|
||||
if (foo[i][permu[i][j]]) {
|
||||
return true;
|
||||
} else {
|
||||
foo[i][permu[i][j]] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main method for the Enigma-Simulation.
|
||||
* @param args All parameter given to the Shell
|
||||
* @throws IOException IOException
|
||||
*/
|
||||
public static void main(final String[] args) throws IOException {
|
||||
int[][] permu = new int[(args.length / ROTORARGS)][Shell.symbols];
|
||||
int[] tickPos = new int[(args.length / ROTORARGS)];
|
||||
int[] initialPos = new int[(args.length / ROTORARGS)];
|
||||
Enigma myEnigma;
|
||||
|
||||
if (checkArgsLength(args)) {
|
||||
if (extractPermuArray(args) != null) {
|
||||
permu = extractPermuArray(args);
|
||||
} else {
|
||||
System.out.println("Error! Wrong Permutation!");
|
||||
return;
|
||||
}
|
||||
if (extractTickPosArray(args) != null) {
|
||||
tickPos = extractTickPosArray(args);
|
||||
} else {
|
||||
System.out.println("Error! wrong Tick Position!");
|
||||
return;
|
||||
}
|
||||
if (extractInitialPosArray(args) != null) {
|
||||
initialPos = extractInitialPosArray(args);
|
||||
} else {
|
||||
System.out.println("Error! wrong initial Position!");
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
System.out.println("Error: wrong number of Arguments");
|
||||
return;
|
||||
}
|
||||
//Check if only Capital Letters are used
|
||||
if (!isEnigmaCharArray(permu) || !isEnigmaCharArray(tickPos)
|
||||
|| !isEnigmaCharArray(initialPos)) {
|
||||
System.out.print("Error! wrong character in config");
|
||||
return;
|
||||
}
|
||||
if (hasDuplicateChar(extractPermuArray(args))) {
|
||||
System.out.println("Error! Duplicate char in Permutation");
|
||||
}
|
||||
|
||||
BufferedReader br =
|
||||
new BufferedReader(new InputStreamReader(System.in));
|
||||
|
||||
myEnigma = new Enigma(tickPos, initialPos, permu, PATCHBOARDPERMU
|
||||
, REFLECTORPERMU);
|
||||
|
||||
|
||||
while (true) {
|
||||
String stdinp = br.readLine();
|
||||
if (stdinp.equals("")) {
|
||||
return;
|
||||
}
|
||||
int[] ciphertxt = convertCharInt(stdinp.toCharArray());
|
||||
if (!isEnigmaCharArray(ciphertxt)) {
|
||||
System.out.print("Error! Wrong input");
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < ciphertxt.length; i++) {
|
||||
System.out.print(convertIntChar(myEnigma.encode(ciphertxt[i])));
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user