Emulation of the WW2 SIGABA machine
I have created an emulation of the SIGABA machine and have tested it against some test data from a Master's thesis by Miao Ai: https://scholarworks.sjsu.edu/cgi/viewcontent.cgi?article=1237&context=etd_projects
This commit is contained in:
hettysymes
hettysymes
parent
616b38c6fb
commit
f007c093eb
501
src/core/lib/SIGABA.mjs
Normal file
501
src/core/lib/SIGABA.mjs
Normal file
@ -0,0 +1,501 @@
|
||||
/**
|
||||
Emulation of the SIGABA machine
|
||||
|
||||
@author hettysymes
|
||||
*/
|
||||
|
||||
/**
|
||||
A set of randomised example SIGABA cipher/control rotors (these rotors are interchangeable). Cipher and control rotors can be referred to as C and R rotors respectively.
|
||||
*/
|
||||
|
||||
export const CR_ROTORS = [
|
||||
{name: "Example 1", value: "SRGWANHPJZFXVIDQCEUKBYOLMT"},
|
||||
{name: "Example 2", value: "THQEFSAZVKJYULBODCPXNIMWRG"},
|
||||
{name: "Example 3", value: "XDTUYLEVFNQZBPOGIRCSMHWKAJ"},
|
||||
{name: "Example 4", value: "LOHDMCWUPSTNGVXYFJREQIKBZA"},
|
||||
{name: "Example 5", value: "ERXWNZQIJYLVOFUMSGHTCKPBDA"},
|
||||
{name: "Example 6", value: "FQECYHJIOUMDZVPSLKRTGWXBAN"},
|
||||
{name: "Example 7", value: "TBYIUMKZDJSOPEWXVANHLCFQGR"},
|
||||
{name: "Example 8", value: "QZUPDTFNYIAOMLEBWJXCGHKRSV"},
|
||||
{name: "Example 9", value: "CZWNHEMPOVXLKRSIDGJFYBTQAU"},
|
||||
{name: "Example 10", value: "ENPXJVKYQBFZTICAGMOHWRLDUS"}
|
||||
];
|
||||
|
||||
/**
|
||||
A set of randomised example SIGABA index rotors (may be referred to as I rotors).
|
||||
*/
|
||||
|
||||
export const I_ROTORS = [
|
||||
{name: "Example 1", value: "6201348957"},
|
||||
{name: "Example 2", value: "6147253089"},
|
||||
{name: "Example 3", value: "8239647510"},
|
||||
{name: "Example 4", value: "7194835260"},
|
||||
{name: "Example 5", value: "4873205916"}
|
||||
];
|
||||
|
||||
export const NUMBERS = "0123456789".split("");
|
||||
|
||||
/**
|
||||
Converts a letter to uppercase (if it already isn't)
|
||||
|
||||
@param {char} letter - letter to convert to upper case
|
||||
@returns {char}
|
||||
*/
|
||||
export function convToUpperCase(letter){
|
||||
const charCode = letter.charCodeAt();
|
||||
if (97<=charCode && charCode<=122){
|
||||
return String.fromCharCode(charCode-32);
|
||||
}
|
||||
return letter;
|
||||
}
|
||||
|
||||
/**
|
||||
The SIGABA machine consisting of the 3 rotor banks: cipher, control and index banks.
|
||||
*/
|
||||
export class SigabaMachine{
|
||||
/**
|
||||
SigabaMachine constructor
|
||||
|
||||
@param {Object[]} cipherRotors - list of CRRotors
|
||||
@param {Object[]} controlRotors - list of CRRotors
|
||||
@param {object[]} indexRotors - list of IRotors
|
||||
*/
|
||||
constructor(cipherRotors, controlRotors, indexRotors){
|
||||
this.cipherBank = new CipherBank(cipherRotors);
|
||||
this.controlBank = new ControlBank(controlRotors);
|
||||
this.indexBank = new IndexBank(indexRotors);
|
||||
}
|
||||
|
||||
/**
|
||||
Steps all the correct rotors in the machine.
|
||||
*/
|
||||
step(){
|
||||
const controlOut = this.controlBank.goThroughControl();
|
||||
const indexOut = this.indexBank.goThroughIndex(controlOut);
|
||||
this.cipherBank.step(indexOut);
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a letter. A space is converted to a "Z" before encryption, and a "Z" is converted to an "X". This allows spaces to be encrypted.
|
||||
|
||||
@param {char} letter - letter to encrypt
|
||||
@returns {char}
|
||||
*/
|
||||
encryptLetter(letter){
|
||||
letter = convToUpperCase(letter);
|
||||
if (letter == " "){
|
||||
letter = "Z";
|
||||
}
|
||||
else if (letter == "Z") {
|
||||
letter = "X";
|
||||
}
|
||||
const encryptedLetter = this.cipherBank.encrypt(letter);
|
||||
this.step();
|
||||
return encryptedLetter;
|
||||
}
|
||||
|
||||
/**
|
||||
Decrypts a letter. A letter decrypted as a "Z" is converted to a space before it is output, since spaces are converted to "Z"s before encryption.
|
||||
|
||||
@param {char} letter - letter to decrypt
|
||||
@returns {char}
|
||||
*/
|
||||
decryptLetter(letter){
|
||||
letter = convToUpperCase(letter);
|
||||
let decryptedLetter = this.cipherBank.decrypt(letter);
|
||||
if (decryptedLetter == "Z"){
|
||||
decryptedLetter = " ";
|
||||
}
|
||||
this.step();
|
||||
return decryptedLetter;
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a message of one or more letters
|
||||
|
||||
@param {string} msg - message to encrypt
|
||||
@returns {string}
|
||||
*/
|
||||
encrypt(msg){
|
||||
let ciphertext = "";
|
||||
for (const letter of msg){
|
||||
ciphertext = ciphertext.concat(this.encryptLetter(letter));
|
||||
}
|
||||
return ciphertext;
|
||||
}
|
||||
|
||||
/**
|
||||
Decrypts a message of one or more letters
|
||||
|
||||
@param {string} msg - message to decrypt
|
||||
@returns {string}
|
||||
*/
|
||||
decrypt(msg){
|
||||
let plaintext = "";
|
||||
for (const letter of msg){
|
||||
plaintext = plaintext.concat(this.decryptLetter(letter));
|
||||
}
|
||||
return plaintext;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
The cipher rotor bank consists of 5 cipher rotors in either a forward or reversed orientation.
|
||||
*/
|
||||
export class CipherBank{
|
||||
/**
|
||||
CipherBank constructor
|
||||
|
||||
@param {Object[]} rotors - list of CRRotors
|
||||
*/
|
||||
constructor(rotors){
|
||||
this.rotors = rotors;
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a letter through the cipher rotors (signal goes from left-to-right)
|
||||
|
||||
@param {char} inputPos - the input position of the signal (letter to be encrypted)
|
||||
@returns {char}
|
||||
*/
|
||||
encrypt(inputPos){
|
||||
for (let rotor of this.rotors){
|
||||
inputPos = rotor.crypt(inputPos, "leftToRight");
|
||||
}
|
||||
return inputPos;
|
||||
}
|
||||
|
||||
/**
|
||||
Decrypts a letter through the cipher rotors (signal goes from right-to-left)
|
||||
|
||||
@param {char} inputPos - the input position of the signal (letter to be decrypted)
|
||||
@returns {char}
|
||||
*/
|
||||
decrypt(inputPos){
|
||||
const revOrderedRotors = [...this.rotors].reverse();
|
||||
for (let rotor of revOrderedRotors){
|
||||
inputPos = rotor.crypt(inputPos, "rightToLeft");
|
||||
}
|
||||
return inputPos;
|
||||
}
|
||||
|
||||
/**
|
||||
Step the cipher rotors forward according to the inputs from the index rotors
|
||||
|
||||
@param {number[]} indexInputs - the inputs from the index rotors
|
||||
*/
|
||||
step(indexInputs){
|
||||
const logicDict = {0: [0,9], 1:[7,8], 2:[5,6], 3:[3,4], 4:[1,2]};
|
||||
let rotorsToMove = [];
|
||||
for (const key in logicDict){
|
||||
const item = logicDict[key];
|
||||
for (const i of indexInputs){
|
||||
if (item.includes(i)){
|
||||
rotorsToMove.push(this.rotors[key]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (let rotor of rotorsToMove){
|
||||
rotor.step();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
The control rotor bank consists of 5 control rotors in either a forward or reversed orientation. Signals to the control rotor bank always go from right-to-left.
|
||||
*/
|
||||
export class ControlBank{
|
||||
/**
|
||||
ControlBank constructor. The rotors have been reversed as signals go from right-to-left through the control rotors.
|
||||
|
||||
@param {Object[]} rotors - list of CRRotors
|
||||
*/
|
||||
constructor(rotors){
|
||||
this.rotors = [...rotors].reverse();
|
||||
this.numberOfMoves = 1;
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a letter.
|
||||
|
||||
@param {char} inputPos - the input position of the signal
|
||||
@returns {char}
|
||||
*/
|
||||
crypt(inputPos){
|
||||
for (let rotor of this.rotors){
|
||||
inputPos = rotor.crypt(inputPos, "rightToLeft");
|
||||
}
|
||||
return inputPos;
|
||||
}
|
||||
|
||||
/**
|
||||
Gets the outputs of the control rotors. The inputs to the control rotors are always "F", "G", "H" and "I".
|
||||
|
||||
@returns {number[]}
|
||||
*/
|
||||
getOutputs(){
|
||||
const outputs = [this.crypt("F"), this.crypt("G"), this.crypt("H"), this.crypt("I")];
|
||||
const logicDict = {1:"B", 2:"C", 3:"DE", 4:"FGH", 5:"IJK", 6:"LMNO", 7:"PQRST", 8:"UVWXYZ", 9:"A"};
|
||||
let numberOutputs = [];
|
||||
for (let key in logicDict){
|
||||
const item = logicDict[key];
|
||||
for (let output of outputs){
|
||||
if (item.includes(output)){
|
||||
numberOutputs.push(key);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return numberOutputs;
|
||||
}
|
||||
|
||||
/**
|
||||
Steps the control rotors. Only 3 of the control rotors step: one after every encryption, one after every 26, and one after every 26 squared.
|
||||
*/
|
||||
step(){
|
||||
const MRotor = this.rotors[1], FRotor = this.rotors[2], SRotor = this.rotors[3];
|
||||
this.numberOfMoves ++;
|
||||
FRotor.step();
|
||||
if (this.numberOfMoves%26 == 0){
|
||||
MRotor.step();
|
||||
}
|
||||
if (this.numberOfMoves%(26*26) == 0){
|
||||
SRotor.step();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
The goThroughControl function combines getting the outputs from the control rotor bank and then stepping them.
|
||||
|
||||
@returns {number[]}
|
||||
*/
|
||||
goThroughControl(){
|
||||
const outputs = this.getOutputs();
|
||||
this.step();
|
||||
return outputs;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
The index rotor bank consists of 5 index rotors all placed in the forwards orientation.
|
||||
*/
|
||||
export class IndexBank{
|
||||
/**
|
||||
IndexBank constructor
|
||||
|
||||
@param {Object[]} rotors - list of IRotors
|
||||
*/
|
||||
constructor(rotors){
|
||||
this.rotors = rotors;
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a number.
|
||||
|
||||
@param {number} inputPos - the input position of the signal
|
||||
@returns {number}
|
||||
*/
|
||||
crypt(inputPos){
|
||||
for (let rotor of this.rotors){
|
||||
inputPos = rotor.crypt(inputPos);
|
||||
}
|
||||
return inputPos;
|
||||
}
|
||||
|
||||
/**
|
||||
The goThroughIndex function takes the inputs from the control rotor bank and returns the list of outputs after encryption through the index rotors.
|
||||
|
||||
@param {number[]} - inputs from the control rotors
|
||||
@returns {number[]}
|
||||
*/
|
||||
goThroughIndex(controlInputs){
|
||||
let outputs = [];
|
||||
for (const inp of controlInputs){
|
||||
outputs.push(this.crypt(inp));
|
||||
}
|
||||
return outputs;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
Rotor class
|
||||
*/
|
||||
export class Rotor{
|
||||
/**
|
||||
Rotor constructor
|
||||
|
||||
@param {number[]} wireSetting - the wirings within the rotor: mapping from left-to-right, the index of the number in the list maps onto the number at that index
|
||||
@param {bool} rev - true if the rotor is reversed, false if it isn't
|
||||
@param {number} key - the starting position or state of the rotor
|
||||
*/
|
||||
constructor(wireSetting, key, rev){
|
||||
this.state = key;
|
||||
this.numMapping = this.getNumMapping(wireSetting, rev);
|
||||
this.posMapping = this.getPosMapping(rev);
|
||||
}
|
||||
|
||||
/**
|
||||
Get the number mapping from the wireSetting (only different from wireSetting if rotor is reversed)
|
||||
|
||||
@param {number[]} wireSetting - the wirings within the rotors
|
||||
@param {bool} rev - true if reversed, false if not
|
||||
@returns {number[]}
|
||||
*/
|
||||
getNumMapping(wireSetting, rev){
|
||||
if (rev==false){
|
||||
return wireSetting;
|
||||
}
|
||||
else {
|
||||
const length = wireSetting.length;
|
||||
let tempMapping = new Array(length);
|
||||
for (let i=0; i<length; i++){
|
||||
tempMapping[wireSetting[i]] = i;
|
||||
}
|
||||
return tempMapping;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Get the position mapping (how the position numbers map onto the numbers of the rotor)
|
||||
|
||||
@param {bool} rev - true if reversed, false if not
|
||||
@returns {number[]}
|
||||
*/
|
||||
getPosMapping(rev){
|
||||
const length = this.numMapping.length;
|
||||
let posMapping = [];
|
||||
if (rev==false){
|
||||
for (let i=this.state; i<this.state+length; i++){
|
||||
let res = i%length;
|
||||
if (res<0){
|
||||
res += length;
|
||||
}
|
||||
posMapping.push(res);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (let i=this.state; i>this.state-length; i--){
|
||||
let res = i%length;
|
||||
if (res<0){
|
||||
res += length;
|
||||
}
|
||||
posMapping.push(res);
|
||||
}
|
||||
}
|
||||
return posMapping;
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypt/decrypt data. This process is identical to the rotors of cipher machines such as Enigma or Typex.
|
||||
|
||||
@param {number} inputPos - the input position of the signal (the data to encrypt/decrypt)
|
||||
@param {string} direction - one of "leftToRight" and "rightToLeft", states the direction in which the signal passes through the rotor
|
||||
@returns {number}
|
||||
*/
|
||||
cryptNum(inputPos, direction){
|
||||
const inpNum = this.posMapping[inputPos];
|
||||
var outNum;
|
||||
if (direction == "leftToRight"){
|
||||
outNum = this.numMapping[inpNum];
|
||||
}
|
||||
else if (direction == "rightToLeft") {
|
||||
outNum = this.numMapping.indexOf(inpNum);
|
||||
}
|
||||
const outPos = this.posMapping.indexOf(outNum);
|
||||
return outPos;
|
||||
}
|
||||
|
||||
/**
|
||||
Steps the rotor. The number at position 0 will be moved to position 1 etc.
|
||||
*/
|
||||
step(){
|
||||
const lastNum = this.posMapping.pop();
|
||||
this.posMapping.splice(0, 0, lastNum);
|
||||
this.state = this.posMapping[0];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
A CRRotor is a cipher (C) or control (R) rotor. These rotors are identical and interchangeable. A C or R rotor consists of 26 contacts, one for each letter, and may be put into either a forwards of reversed orientation.
|
||||
*/
|
||||
export class CRRotor extends Rotor{
|
||||
|
||||
/**
|
||||
CRRotor constructor
|
||||
|
||||
@param {string} wireSetting - the rotor wirings (string of letters)
|
||||
@param {char} key - initial state of rotor
|
||||
@param {bool} rev - true if reversed, false if not
|
||||
*/
|
||||
constructor(wireSetting, key, rev=false){
|
||||
wireSetting = wireSetting.split("").map(CRRotor.letterToNum);
|
||||
super(wireSetting, CRRotor.letterToNum(key), rev);
|
||||
}
|
||||
|
||||
/**
|
||||
Static function which converts a letter into its number i.e. its offset from the letter "A"
|
||||
|
||||
@param {char} letter - letter to convert to number
|
||||
@returns {number}
|
||||
*/
|
||||
static letterToNum(letter){
|
||||
return letter.charCodeAt()-65;
|
||||
}
|
||||
|
||||
/**
|
||||
Static function which converts a number (a letter's offset from "A") into its letter
|
||||
|
||||
@param {number} num - number to convert to letter
|
||||
@returns {char}
|
||||
*/
|
||||
static numToLetter(num){
|
||||
return String.fromCharCode(num+65);
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts/decrypts a letter.
|
||||
|
||||
@param {char} inputPos - the input position of the signal ("A" refers to position 0 etc.)
|
||||
@param {string} direction - one of "leftToRight" and "rightToLeft"
|
||||
@returns {char}
|
||||
*/
|
||||
crypt(inputPos, direction){
|
||||
inputPos = CRRotor.letterToNum(inputPos);
|
||||
const outPos = this.cryptNum(inputPos, direction);
|
||||
return CRRotor.numToLetter(outPos);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
An IRotor is an index rotor, which consists of 10 contacts each numbered from 0 to 9. Unlike C and R rotors, they cannot be put in the reversed orientation. The index rotors do not step at any point during encryption or decryption.
|
||||
*/
|
||||
export class IRotor extends Rotor{
|
||||
/**
|
||||
IRotor constructor
|
||||
|
||||
@param {string} wireSetting - the rotor wirings (string of numbers)
|
||||
@param {char} key - initial state of rotor
|
||||
*/
|
||||
constructor(wireSetting, key){
|
||||
wireSetting = wireSetting.split("").map(Number);
|
||||
super(wireSetting, Number(key), false);
|
||||
}
|
||||
|
||||
/**
|
||||
Encrypts a number
|
||||
|
||||
@param {number} inputPos - the input position of the signal
|
||||
@returns {number}
|
||||
*/
|
||||
crypt(inputPos){
|
||||
return this.cryptNum(inputPos, "leftToRight");
|
||||
}
|
||||
|
||||
}
|
||||
293
src/core/operations/SIGABA.mjs
Normal file
293
src/core/operations/SIGABA.mjs
Normal file
@ -0,0 +1,293 @@
|
||||
/**
|
||||
Emulation of the SIGABA machine.
|
||||
|
||||
@author hettysymes
|
||||
*/
|
||||
|
||||
import Operation from "../Operation.mjs";
|
||||
import OperationError from "../errors/OperationError.mjs";
|
||||
import {LETTERS} from "../lib/Enigma.mjs";
|
||||
import {NUMBERS, CR_ROTORS, I_ROTORS, SigabaMachine, CRRotor, IRotor} from "../lib/SIGABA.mjs";
|
||||
|
||||
/**
|
||||
Sigaba operation
|
||||
*/
|
||||
class Sigaba extends Operation{
|
||||
/**
|
||||
Sigaba constructor
|
||||
*/
|
||||
constructor(){
|
||||
super();
|
||||
|
||||
this.name = "SIGABA";
|
||||
this.module = "SIGABA";
|
||||
this.description = "Encipher/decipher with the WW2 SIGABA machine. <br><br>SIGABA, otherwise known as ECM Mark II, was used by the United States for message encryption during WW2 up to the 1950s. It was developed in the 1930s by the US Army and Navy, and has up to this day never been broken. The idea behind its design was to truly randomise the motion of the rotors. In comparison, Enigma, which rotates its rotors once every key pressed, has much less randomised rotor movements. Consisting of 15 rotors: 5 cipher rotors and 10 rotors (5 control rotors and 5 index rotors) controlling the stepping of the cipher rotors, the rotor stepping for SIGABA is much more complex. All example rotor wirings are random example sets.<br><br>To configure rotor wirings, for the cipher and control rotors enter a string of letters which map from A to Z, and for the index rotors enter a sequence of numbers which map from 0 to 9. Note that encryption is not the same as decryption, so first choose the desired mode.";
|
||||
this.infoURL = "https://en.wikipedia.org/wiki/SIGABA";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
{
|
||||
name: "1st (left-hand) cipher rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "1st cipher rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "1st cipher rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "2nd cipher rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "2nd cipher rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "2nd cipher rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "3rd (middle) cipher rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "3rd cipher rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "3rd cipher rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "4th cipher rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "4th cipher rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "4th cipher rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "5th (right-hand) cipher rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "5th cipher rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "5th cipher rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "1st (left-hand) control rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "1st control rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "1st control rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "2nd control rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "2nd control rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "2nd control rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "3rd (middle) control rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "3rd control rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "3rd control rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "4th control rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "4th control rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "4th control rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "5th (right-hand) control rotor",
|
||||
type: "editableOption",
|
||||
value: CR_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "5th control rotor reversed",
|
||||
type: "boolean",
|
||||
value: false
|
||||
},
|
||||
{
|
||||
name: "5th control rotor intial value",
|
||||
type: "option",
|
||||
value: LETTERS
|
||||
},
|
||||
{
|
||||
name: "1st (left-hand) index rotor",
|
||||
type: "editableOption",
|
||||
value: I_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "1st index rotor intial value",
|
||||
type: "option",
|
||||
value: NUMBERS
|
||||
},
|
||||
{
|
||||
name: "2nd index rotor",
|
||||
type: "editableOption",
|
||||
value: I_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "2nd index rotor intial value",
|
||||
type: "option",
|
||||
value: NUMBERS
|
||||
},
|
||||
{
|
||||
name: "3rd (middle) index rotor",
|
||||
type: "editableOption",
|
||||
value: I_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "3rd index rotor intial value",
|
||||
type: "option",
|
||||
value: NUMBERS
|
||||
},
|
||||
{
|
||||
name: "4th index rotor",
|
||||
type: "editableOption",
|
||||
value: I_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "4th index rotor intial value",
|
||||
type: "option",
|
||||
value: NUMBERS
|
||||
},
|
||||
{
|
||||
name: "5th (right-hand) index rotor",
|
||||
type: "editableOption",
|
||||
value: I_ROTORS,
|
||||
defaultIndex: 0
|
||||
},
|
||||
{
|
||||
name: "5th index rotor intial value",
|
||||
type: "option",
|
||||
value: NUMBERS
|
||||
},
|
||||
{
|
||||
name: "SIGABA mode",
|
||||
type: "option",
|
||||
value: ["Encrypt", "Decrypt"]
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@param {string} rotor - rotor wirings
|
||||
@returns {string}
|
||||
*/
|
||||
|
||||
parseRotorStr(rotor){
|
||||
if (rotor === ""){
|
||||
throw new OperationError(`All rotor wirings must be provided.`);
|
||||
}
|
||||
return rotor;
|
||||
}
|
||||
|
||||
run(input, args){
|
||||
const sigabaSwitch = args[40];
|
||||
const cipherRotors = [];
|
||||
const controlRotors = [];
|
||||
const indexRotors = [];
|
||||
for (let i=0; i<5; i++){
|
||||
const rotorWiring = this.parseRotorStr(args[i*3]);
|
||||
cipherRotors.push(new CRRotor(rotorWiring, args[i*3+2], args[i*3+1]));
|
||||
}
|
||||
for (let i=5; i<10; i++){
|
||||
const rotorWiring = this.parseRotorStr(args[i*3]);
|
||||
controlRotors.push(new CRRotor(rotorWiring, args[i*3+2], args[i*3+1]));
|
||||
}
|
||||
for (let i=15; i<20; i++){
|
||||
const rotorWiring = this.parseRotorStr(args[i*2]);
|
||||
indexRotors.push(new IRotor(rotorWiring, args[i*2+1]));
|
||||
}
|
||||
const sigaba = new SigabaMachine(cipherRotors, controlRotors, indexRotors);
|
||||
var result;
|
||||
if (sigabaSwitch === "Encrypt"){
|
||||
result = sigaba.encrypt(input);
|
||||
}
|
||||
else if (sigabaSwitch === "Decrypt") {
|
||||
result = sigaba.decrypt(input);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
export default Sigaba;
|
||||
Loading…
Reference in New Issue
Block a user