Zoltan Hudak / Enigma

Encryption library based on the Enigma machine. It's capable to encrypt any byte, not only the 26 capital letters of the alphabet.

Dependents:   Enigma_Hello

Encryption library based on the Enigma machine. It is capable to encrypt any byte, not only the 26 capital letters of the alphabet as the original Enigma machine did. Combining three rotors from a set of five, each of the 3 rotor setting with 256 positions, and the plugboard with 120 pairs of plugs connected it has staggering (5 * 4 * 3) * 256^3 * [256! / ((256 - 2 * 120)! * 120! * 2^120)] = 4.6415160521069700910027304860568e+267 different settings. In other words, it uses a 889-bit key for encryption & decryption of data.

Enigma.cpp@4:107a360171fe, 2019-09-24 (annotated)

Committer:
hudakz
Date:
Tue Sep 24 16:56:56 2019 +0000
Revision:
4:107a360171fe
Parent:
3:9590c44c9ecd 
Encryption library based on the Enigma machine. It's capable to encrypt any byte, not only the 26 capital letters of the alphabet.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
hudakz 0:7a702d2d6b54 1 #include "Enigma.h"
hudakz 0:7a702d2d6b54 2
hudakz 0:7a702d2d6b54 3 /*$off*/
hudakz 0:7a702d2d6b54 4 // Internal wiring of the five available rotors
hudakz 0:7a702d2d6b54 5 const uint8_t Enigma::ROTOR_I[256] = {
hudakz 4:107a360171fe 6 0xE0, 0xD7, 0xF1, 0x7A, 0x92, 0x84, 0x5E, 0x1B, 0xD6, 0x38, 0x79, 0x10, 0x7C, 0xA6, 0x1F, 0x4D,
hudakz 4:107a360171fe 7 0x4F, 0x30, 0x19, 0xDD, 0x61, 0x00, 0xA2, 0x82, 0x98, 0xF9, 0x2F, 0x6A, 0xC5, 0x64, 0x9D, 0x9B,
hudakz 4:107a360171fe 8 0xCA, 0x17, 0xD4, 0x24, 0x2B, 0x20, 0xD5, 0xEA, 0xBA, 0x25, 0x2E, 0x08, 0x78, 0x32, 0xAF, 0xE6,
hudakz 4:107a360171fe 9 0x4C, 0x13, 0x56, 0xBD, 0xD9, 0xE5, 0x33, 0xEE, 0x69, 0xF3, 0x0F, 0x99, 0xBB, 0x4E, 0x01, 0x77,
hudakz 4:107a360171fe 10 0x9C, 0x91, 0xF0, 0x89, 0xF8, 0x74, 0xB1, 0x95, 0x88, 0x42, 0xD0, 0x50, 0xFC, 0xA7, 0x7E, 0x7D,
hudakz 4:107a360171fe 11 0x59, 0x73, 0x6D, 0x45, 0x5B, 0x3D, 0x3B, 0x34, 0x97, 0xED, 0xDE, 0x47, 0xF4, 0xE1, 0x60, 0xE4,
hudakz 4:107a360171fe 12 0x2A, 0xAD, 0xFB, 0x81, 0xA9, 0x29, 0x57, 0x51, 0xC4, 0x3F, 0x53, 0x1D, 0xBE, 0x06, 0xFA, 0x85,
hudakz 4:107a360171fe 13 0x12, 0x3A, 0x8A, 0x96, 0x63, 0x07, 0x8C, 0xD3, 0x72, 0xE3, 0x54, 0xCB, 0x4B, 0x35, 0x0B, 0xEB,
hudakz 4:107a360171fe 14 0xDA, 0xD2, 0x3E, 0x7F, 0x1A, 0xB6, 0x0C, 0xC0, 0xB2, 0xC8, 0xA8, 0x66, 0x39, 0x8E, 0xF5, 0xA4,
hudakz 4:107a360171fe 15 0xDF, 0xE2, 0x8D, 0x44, 0x31, 0x7B, 0x14, 0xDC, 0xA3, 0xC3, 0xFD, 0x1E, 0xEF, 0x23, 0x9A, 0x2D,
hudakz 4:107a360171fe 16 0xF7, 0xB8, 0xC1, 0x94, 0x36, 0x5D, 0x48, 0x68, 0x80, 0xEC, 0x4A, 0x41, 0xB4, 0xE8, 0x16, 0x6E,
hudakz 4:107a360171fe 17 0x49, 0x43, 0x18, 0x11, 0x9F, 0xD8, 0x8B, 0x83, 0xCC, 0x03, 0xCF, 0x5C, 0x27, 0xC6, 0x02, 0xE7,
hudakz 4:107a360171fe 18 0xCD, 0x70, 0x5A, 0x04, 0xFF, 0xC7, 0xB0, 0x76, 0xB7, 0x26, 0xB3, 0xCE, 0x15, 0x6C, 0xB5, 0x0D,
hudakz 4:107a360171fe 19 0x93, 0x09, 0xF2, 0xDB, 0xBC, 0x37, 0xAA, 0x87, 0xF6, 0xAB, 0x67, 0x21, 0x28, 0xC2, 0xC9, 0x52,
hudakz 4:107a360171fe 20 0x0E, 0x5F, 0x58, 0xAE, 0x22, 0x6F, 0x86, 0x2C, 0x0A, 0x1C, 0x62, 0x9E, 0xA5, 0x46, 0x05, 0xAC,
hudakz 4:107a360171fe 21 0x65, 0x40, 0x75, 0x6B, 0xB9, 0xE9, 0xD1, 0x8F, 0x71, 0xFE, 0x55, 0xA0, 0xA1, 0x3C, 0x90, 0xBF
hudakz 0:7a702d2d6b54 22 };
hudakz 0:7a702d2d6b54 23
hudakz 0:7a702d2d6b54 24 const uint8_t Enigma::ROTOR_II[256] = {
hudakz 4:107a360171fe 25 0xFF, 0xA2, 0x4F, 0x1A, 0x1B, 0x20, 0x9B, 0xEC, 0x47, 0x3E, 0xE7, 0x0D, 0x0F, 0x34, 0x50, 0x46,
hudakz 4:107a360171fe 26 0x41, 0x9A, 0xF6, 0x63, 0xB6, 0x83, 0xEA, 0x51, 0x88, 0xD4, 0xC1, 0x52, 0x42, 0x37, 0xC0, 0xC6,
hudakz 4:107a360171fe 27 0xE3, 0x1E, 0xF7, 0xA9, 0x60, 0x4B, 0xDA, 0x2D, 0x94, 0x7F, 0x85, 0x2F, 0xA0, 0x6A, 0xFA, 0xC8,
hudakz 4:107a360171fe 28 0xDE, 0x06, 0x8D, 0x75, 0xF8, 0xEE, 0xAA, 0xC7, 0xEF, 0x38, 0x14, 0x69, 0x23, 0x05, 0x8C, 0x3D,
hudakz 4:107a360171fe 29 0x5D, 0xC9, 0x13, 0x2E, 0xAB, 0x6C, 0x32, 0xC5, 0xFC, 0xB4, 0xB0, 0x98, 0x1D, 0xBC, 0x2A, 0xA6,
hudakz 4:107a360171fe 30 0x3F, 0xF2, 0xAC, 0xC4, 0x8E, 0xBB, 0xF9, 0x49, 0xAD, 0x9C, 0xD5, 0x57, 0xEB, 0xA1, 0x3B, 0x15,
hudakz 4:107a360171fe 31 0x7D, 0x28, 0x89, 0xB5, 0xB7, 0xE1, 0x5B, 0x65, 0xDC, 0x10, 0x82, 0x36, 0xB8, 0x2C, 0x25, 0x7A,
hudakz 4:107a360171fe 32 0x91, 0x2B, 0xFE, 0x9F, 0x07, 0x01, 0xA4, 0x6F, 0xAE, 0x79, 0xF5, 0xD9, 0x48, 0x5C, 0x6D, 0x74,
hudakz 4:107a360171fe 33 0xB1, 0x8A, 0x58, 0x33, 0xD0, 0x6E, 0x40, 0xBD, 0x4D, 0x97, 0xCF, 0x62, 0x84, 0x30, 0x67, 0xA7,
hudakz 4:107a360171fe 34 0xE6, 0xE2, 0xB2, 0x61, 0x80, 0x92, 0x0E, 0x68, 0x4E, 0x66, 0x81, 0x16, 0x90, 0x53, 0x11, 0xBE,
hudakz 4:107a360171fe 35 0x6B, 0xD1, 0x04, 0xD3, 0x08, 0x70, 0x95, 0x93, 0x4C, 0xA5, 0xDF, 0xD6, 0x5E, 0xA8, 0x7E, 0x9E,
hudakz 4:107a360171fe 36 0x19, 0xE0, 0x77, 0x73, 0xBF, 0xF1, 0x21, 0x9D, 0x55, 0xFD, 0xE8, 0x56, 0xDB, 0xCE, 0x64, 0x43,
hudakz 4:107a360171fe 37 0x0C, 0x29, 0x0B, 0x44, 0x31, 0xE9, 0x8F, 0x1F, 0x8B, 0x27, 0xED, 0x3A, 0xFB, 0x12, 0xCA, 0x59,
hudakz 4:107a360171fe 38 0x1C, 0xDD, 0xB3, 0x87, 0x3C, 0x96, 0x78, 0x86, 0x54, 0xD2, 0xCC, 0x26, 0x99, 0xC3, 0x71, 0x02,
hudakz 4:107a360171fe 39 0xF0, 0xE4, 0x45, 0x22, 0x18, 0xD8, 0x5F, 0xD7, 0xB9, 0xCD, 0xBA, 0x5A, 0x7B, 0xF4, 0xAF, 0xA3,
hudakz 4:107a360171fe 40 0x00, 0x24, 0x35, 0x7C, 0x09, 0x39, 0x03, 0x17, 0xCB, 0xF3, 0x72, 0x4A, 0xE5, 0x76, 0xC2, 0x0A
hudakz 0:7a702d2d6b54 41 };
hudakz 0:7a702d2d6b54 42
hudakz 0:7a702d2d6b54 43 const uint8_t Enigma::ROTOR_III[256] = {
hudakz 4:107a360171fe 44 0x1C, 0xB8, 0x5A, 0xA6, 0xC2, 0xF9, 0x78, 0xF6, 0x41, 0x22, 0xD7, 0x1E, 0xAD, 0xCC, 0x96, 0xE0,
hudakz 4:107a360171fe 45 0x59, 0x69, 0x09, 0x73, 0xE8, 0xFC, 0x1A, 0x17, 0xA2, 0x12, 0xFE, 0x00, 0xFD, 0x7E, 0x0C, 0x60,
hudakz 4:107a360171fe 46 0x54, 0x8D, 0x2E, 0xFA, 0x9E, 0xB1, 0xA5, 0x3F, 0x03, 0x7B, 0xB9, 0xBF, 0x90, 0xDD, 0xE5, 0xD2,
hudakz 4:107a360171fe 47 0x2F, 0x99, 0xCD, 0x80, 0x79, 0xCB, 0xC6, 0x5E, 0x31, 0x08, 0x29, 0xEA, 0xD9, 0x58, 0xF2, 0x4F,
hudakz 4:107a360171fe 48 0x4E, 0x02, 0xC0, 0x98, 0x34, 0x47, 0x64, 0xB4, 0xCE, 0x5C, 0x8C, 0xA4, 0x28, 0x83, 0xCF, 0x44,
hudakz 4:107a360171fe 49 0xEC, 0xC9, 0xF4, 0x30, 0x56, 0xB2, 0x1B, 0x8F, 0x07, 0xFF, 0x35, 0x6E, 0x0F, 0x7C, 0xAE, 0x11,
hudakz 4:107a360171fe 50 0xAB, 0xE1, 0x13, 0xA0, 0xC8, 0xE9, 0x2C, 0x70, 0x82, 0x91, 0xEE, 0x76, 0xBB, 0xDE, 0x20, 0x7F,
hudakz 4:107a360171fe 51 0xF0, 0x5B, 0xE4, 0x36, 0xA7, 0x2D, 0x89, 0x53, 0x93, 0x24, 0xA1, 0x3E, 0x51, 0xD0, 0xF8, 0x95,
hudakz 4:107a360171fe 52 0xDB, 0x77, 0x8A, 0x40, 0x8B, 0xC3, 0xDC, 0x3D, 0xD4, 0x9F, 0x19, 0xBE, 0xD3, 0xE7, 0x45, 0x10,
hudakz 4:107a360171fe 53 0x8E, 0x9D, 0x0D, 0x57, 0xA9, 0x72, 0x21, 0x49, 0x52, 0x04, 0xD8, 0xF1, 0xEB, 0x4C, 0xB0, 0x14,
hudakz 4:107a360171fe 54 0x87, 0x55, 0x33, 0xA8, 0x61, 0x38, 0x39, 0x65, 0x42, 0x0E, 0xE2, 0xB5, 0x4B, 0x94, 0x27, 0xF7,
hudakz 4:107a360171fe 55 0x06, 0x48, 0xD6, 0x6D, 0xB3, 0x50, 0x85, 0x6A, 0xBD, 0x3C, 0xDF, 0x6B, 0x67, 0x01, 0xFB, 0x86,
hudakz 4:107a360171fe 56 0x63, 0xF3, 0xBC, 0x23, 0x88, 0xF5, 0xCA, 0x2B, 0x18, 0xC4, 0x3B, 0x5F, 0x84, 0x7D, 0xED, 0xDA,
hudakz 4:107a360171fe 57 0x1D, 0xD1, 0x74, 0x0A, 0x43, 0x75, 0xC7, 0x32, 0x62, 0xB6, 0x16, 0xE6, 0x4A, 0xA3, 0x37, 0x71,
hudakz 4:107a360171fe 58 0x81, 0x26, 0xAF, 0x68, 0x2A, 0x9A, 0x5D, 0x3A, 0x7A, 0xB7, 0xE3, 0x46, 0x0B, 0xD5, 0x25, 0x4D,
hudakz 4:107a360171fe 59 0xC1, 0x66, 0xAA, 0x1F, 0x05, 0xBA, 0x9C, 0x6C, 0x9B, 0xAC, 0x97, 0x6F, 0xEF, 0xC5, 0x92, 0x15
hudakz 0:7a702d2d6b54 60 };
hudakz 0:7a702d2d6b54 61
hudakz 0:7a702d2d6b54 62 const uint8_t Enigma::ROTOR_IV[256] = {
hudakz 4:107a360171fe 63 0xC1, 0x1B, 0x04, 0xE6, 0x4A, 0x89, 0xAA, 0xBE, 0x78, 0x05, 0x8F, 0x1A, 0x02, 0x81, 0x45, 0x3A,
hudakz 4:107a360171fe 64 0xAF, 0xEE, 0x68, 0xD4, 0x71, 0x5D, 0x92, 0x90, 0x36, 0x0D, 0x21, 0x14, 0x46, 0xBC, 0x09, 0xB2,
hudakz 4:107a360171fe 65 0xEF, 0x8D, 0xBA, 0x8C, 0xAC, 0xDD, 0x01, 0xD8, 0xDA, 0xCF, 0xFF, 0xFC, 0xF6, 0x48, 0xF2, 0xB9,
hudakz 4:107a360171fe 66 0x95, 0x59, 0xC4, 0x76, 0xB6, 0xCA, 0x58, 0x2C, 0x07, 0xEC, 0x2A, 0x47, 0x99, 0x8A, 0x31, 0x20,
hudakz 4:107a360171fe 67 0xE2, 0x7F, 0x30, 0xBD, 0x8E, 0xB5, 0x70, 0x0B, 0x18, 0x37, 0x75, 0xB1, 0x94, 0xC7, 0x06, 0x00,
hudakz 4:107a360171fe 68 0x73, 0xC8, 0xCC, 0x9E, 0xE9, 0x2D, 0x1D, 0x44, 0x98, 0x1F, 0x93, 0xFB, 0x41, 0x50, 0xAD, 0x32,
hudakz 4:107a360171fe 69 0x61, 0xBB, 0xF1, 0xFE, 0x24, 0xCE, 0xB4, 0xAB, 0x72, 0xEA, 0x25, 0x67, 0xCD, 0x53, 0x26, 0x7A,
hudakz 4:107a360171fe 70 0x77, 0xA8, 0x23, 0x19, 0x79, 0xD1, 0x9C, 0x5F, 0xF5, 0xC0, 0x1C, 0x5B, 0xE3, 0xC6, 0x6E, 0xD5,
hudakz 4:107a360171fe 71 0xE0, 0x10, 0x3D, 0x66, 0x7D, 0x33, 0x51, 0x6C, 0x82, 0xD6, 0x84, 0x40, 0xDB, 0xE8, 0xC9, 0x62,
hudakz 4:107a360171fe 72 0xF3, 0x5C, 0xD3, 0x60, 0x4D, 0x96, 0x08, 0x8B, 0xFA, 0xD0, 0xB7, 0x7E, 0xC2, 0x55, 0xB8, 0x63,
hudakz 4:107a360171fe 73 0x86, 0x2F, 0x97, 0xA9, 0xA6, 0x3E, 0x34, 0xCB, 0x0E, 0x38, 0x6D, 0xBF, 0xF7, 0x11, 0x6B, 0x0A,
hudakz 4:107a360171fe 74 0xEB, 0xF0, 0x15, 0x0C, 0xB3, 0x12, 0x88, 0xA4, 0x69, 0xD2, 0x9F, 0xA1, 0x9A, 0x39, 0x27, 0x2B,
hudakz 4:107a360171fe 75 0x4F, 0x03, 0x91, 0xA5, 0x3B, 0xDE, 0xF9, 0x4B, 0x28, 0x9B, 0x1E, 0x17, 0xE7, 0x6F, 0xDF, 0x16,
hudakz 4:107a360171fe 76 0x43, 0xF4, 0xDC, 0x7C, 0x87, 0x54, 0xE4, 0xA3, 0x52, 0x0F, 0xE5, 0x49, 0xED, 0x56, 0xFD, 0xE1,
hudakz 4:107a360171fe 77 0x13, 0x22, 0x85, 0x9D, 0x4C, 0xD9, 0x65, 0x3C, 0x6A, 0x5E, 0xB0, 0xA0, 0x29, 0x2E, 0x42, 0x35,
hudakz 4:107a360171fe 78 0xAE, 0x5A, 0x4E, 0xA7, 0xC3, 0x7B, 0xA2, 0x83, 0x64, 0x74, 0xF8, 0xD7, 0x80, 0x3F, 0xC5, 0x57
hudakz 0:7a702d2d6b54 79 };
hudakz 0:7a702d2d6b54 80
hudakz 0:7a702d2d6b54 81 const uint8_t Enigma::ROTOR_V[256] = {
hudakz 4:107a360171fe 82 0xFE, 0xC8, 0x49, 0x21, 0xA5, 0x5A, 0xF4, 0xA8, 0xC3, 0x1B, 0x9A, 0x5E, 0x22, 0xAE, 0x7F, 0xEA,
hudakz 4:107a360171fe 83 0x8F, 0xF1, 0x15, 0x73, 0xE3, 0xCE, 0x05, 0x3C, 0x08, 0x07, 0xEB, 0x96, 0xCF, 0x98, 0x29, 0xBD,
hudakz 4:107a360171fe 84 0x03, 0xAD, 0x9E, 0x32, 0x0E, 0xC1, 0xB9, 0xD2, 0x83, 0xD6, 0x4D, 0x14, 0x1C, 0x68, 0x9D, 0x31,
hudakz 4:107a360171fe 85 0xA2, 0x97, 0x01, 0x7E, 0xE5, 0xF6, 0x2D, 0x27, 0xE8, 0xF5, 0xF9, 0xB2, 0x10, 0x82, 0xD8, 0x66,
hudakz 4:107a360171fe 86 0x76, 0x8E, 0x19, 0xFD, 0xA3, 0xA6, 0x8A, 0xD0, 0x2F, 0xC9, 0xB4, 0x9C, 0xD7, 0x38, 0xDF, 0x99,
hudakz 4:107a360171fe 87 0xEF, 0xC4, 0x09, 0xB1, 0x13, 0x3A, 0x6D, 0xBC, 0x58, 0x7C, 0x4C, 0x11, 0x7D, 0xE2, 0x30, 0xC7,
hudakz 4:107a360171fe 88 0x2B, 0x6B, 0xAB, 0x6E, 0x63, 0x7B, 0xFF, 0x9B, 0x57, 0xD4, 0x61, 0x51, 0x26, 0x37, 0x4A, 0xED,
hudakz 4:107a360171fe 89 0xB6, 0xAC, 0xC5, 0x92, 0x89, 0x91, 0xCC, 0x1F, 0x0C, 0xA0, 0x6F, 0x94, 0xEC, 0xA4, 0xDC, 0x4F,
hudakz 4:107a360171fe 90 0x8B, 0xDB, 0x6C, 0x40, 0xC6, 0x48, 0x54, 0x45, 0x16, 0xE9, 0x6A, 0x20, 0x52, 0x67, 0x55, 0x34,
hudakz 4:107a360171fe 91 0x90, 0x79, 0xF0, 0x33, 0x9F, 0xDA, 0x87, 0xF2, 0x85, 0xF3, 0x00, 0xF7, 0xBF, 0x69, 0xA9, 0x50,
hudakz 4:107a360171fe 92 0x59, 0x36, 0xE0, 0x3D, 0x06, 0x0F, 0x46, 0x44, 0xB5, 0x56, 0xE7, 0x77, 0x3B, 0x5C, 0x0B, 0xE4,
hudakz 4:107a360171fe 93 0x35, 0xC2, 0x72, 0x41, 0x2E, 0x0D, 0xAF, 0xF8, 0xC0, 0x0A, 0x17, 0x24, 0x95, 0x81, 0xEE, 0x1D,
hudakz 4:107a360171fe 94 0x2A, 0xA7, 0xCB, 0xD1, 0x12, 0x02, 0xB7, 0x42, 0x84, 0x4E, 0x28, 0x78, 0x8C, 0x1A, 0xB0, 0x5B,
hudakz 4:107a360171fe 95 0x7A, 0xFA, 0xDE, 0xBB, 0x93, 0x88, 0xCD, 0xE1, 0xFC, 0x04, 0x1E, 0x43, 0x8D, 0x74, 0x80, 0x25,
hudakz 4:107a360171fe 96 0x47, 0xA1, 0xAA, 0x39, 0xDD, 0xB3, 0xD5, 0x3F, 0x65, 0x5D, 0xBA, 0x18, 0x71, 0x60, 0x75, 0x62,
hudakz 4:107a360171fe 97 0x2C, 0x4B, 0x53, 0xCA, 0x64, 0xE6, 0x23, 0x5F, 0x3E, 0x86, 0x70, 0xFB, 0xD3, 0xD9, 0xBE, 0xB8
hudakz 0:7a702d2d6b54 98 };
hudakz 0:7a702d2d6b54 99
hudakz 0:7a702d2d6b54 100 // Internal wiring of the reflector
hudakz 0:7a702d2d6b54 101 const uint8_t Enigma::REFLECTOR[256] = {
hudakz 4:107a360171fe 102 0x31, 0x74, 0x9C, 0xC4, 0x2A, 0x7E, 0xC6, 0x69, 0x19, 0xA3, 0x5D, 0x91, 0xE7, 0x15, 0x2F, 0xA1,
hudakz 4:107a360171fe 103 0x29, 0x7C, 0xD1, 0x80, 0x9E, 0x0D, 0xF0, 0xDA, 0xFF, 0x08, 0xD5, 0xFC, 0xDF, 0xA0, 0x58, 0xAF,
hudakz 4:107a360171fe 104 0x4D, 0xC3, 0x8F, 0x46, 0x97, 0x70, 0xCD, 0x48, 0xEA, 0x10, 0x04, 0xD3, 0x44, 0xD6, 0x51, 0x0E,
hudakz 4:107a360171fe 105 0xFE, 0x00, 0xA2, 0x9D, 0x59, 0x50, 0x98, 0x6C, 0x53, 0x8C, 0xD8, 0x92, 0xA8, 0x87, 0x84, 0x6F,
hudakz 4:107a360171fe 106 0x6D, 0xB6, 0x9A, 0xE3, 0x2C, 0x79, 0x23, 0xA7, 0x27, 0xA9, 0x66, 0xDB, 0xB5, 0x20, 0x68, 0x5B,
hudakz 4:107a360171fe 107 0x35, 0x2E, 0xB1, 0x38, 0x89, 0xC7, 0xF1, 0x96, 0x1E, 0x34, 0xCB, 0x4F, 0x83, 0x0A, 0xF9, 0xFB,
hudakz 4:107a360171fe 108 0x6B, 0xE2, 0xD0, 0x93, 0x71, 0x75, 0x4A, 0x8D, 0x4E, 0x07, 0x86, 0x60, 0x37, 0x40, 0xCC, 0x3F,
hudakz 4:107a360171fe 109 0x25, 0x64, 0xE4, 0xC1, 0x01, 0x65, 0xFA, 0xB4, 0xF4, 0x45, 0xB2, 0xA5, 0x11, 0x7F, 0x05, 0x7D,
hudakz 4:107a360171fe 110 0x13, 0xC8, 0xDD, 0x5C, 0x3E, 0x99, 0x6A, 0x3D, 0xF7, 0x54, 0xAD, 0xC9, 0x39, 0x67, 0xE8, 0x22,
hudakz 4:107a360171fe 111 0xEF, 0x0B, 0x3B, 0x63, 0xF2, 0xD4, 0x57, 0x24, 0x36, 0x85, 0x42, 0xAB, 0x02, 0x33, 0x14, 0xED,
hudakz 4:107a360171fe 112 0x1D, 0x0F, 0x32, 0x09, 0xD7, 0x7B, 0xB0, 0x47, 0x3C, 0x49, 0xFD, 0x9B, 0xE6, 0x8A, 0xE0, 0x1F,
hudakz 4:107a360171fe 113 0xA6, 0x52, 0x7A, 0xBD, 0x77, 0x4C, 0x41, 0xBF, 0xF6, 0xBB, 0xD9, 0xB9, 0xDC, 0xB3, 0xC0, 0xB7,
hudakz 4:107a360171fe 114 0xBE, 0x73, 0xD2, 0x21, 0x03, 0xCE, 0x06, 0x55, 0x81, 0x8B, 0xE5, 0x5A, 0x6E, 0x26, 0xC5, 0xEE,
hudakz 4:107a360171fe 115 0x62, 0x12, 0xC2, 0x2B, 0x95, 0x1A, 0x2D, 0xA4, 0x3A, 0xBA, 0x17, 0x4B, 0xBC, 0x82, 0xEC, 0x1C,
hudakz 4:107a360171fe 116 0xAE, 0xF5, 0x61, 0x43, 0x72, 0xCA, 0xAC, 0x0C, 0x8E, 0xF3, 0x28, 0xF8, 0xDE, 0x9F, 0xCF, 0x90,
hudakz 4:107a360171fe 117 0x16, 0x56, 0x94, 0xE9, 0x78, 0xE1, 0xB8, 0x88, 0xEB, 0x5E, 0x76, 0x5F, 0x1B, 0xAA, 0x30, 0x18
hudakz 0:7a702d2d6b54 118 };
hudakz 0:7a702d2d6b54 119 /*$on*/
hudakz 0:7a702d2d6b54 120
hudakz 0:7a702d2d6b54 121 /**
hudakz 0:7a702d2d6b54 122 * @brief Constructor
hudakz 0:7a702d2d6b54 123 * @note Selects which rotors are going to be used and sets their intial position.
hudakz 4:107a360171fe 124 * @note Also connects pairs of plugs with cords on the plugboard.
hudakz 0:7a702d2d6b54 125 * @param
hudakz 0:7a702d2d6b54 126 * @retval
hudakz 0:7a702d2d6b54 127 */
hudakz 0:7a702d2d6b54 128 Enigma::Enigma
hudakz 0:7a702d2d6b54 129 (
hudakz 0:7a702d2d6b54 130 const uint8_t* leftRotorSel,
hudakz 0:7a702d2d6b54 131 const uint8_t* middleRotorSel,
hudakz 0:7a702d2d6b54 132 const uint8_t* rightRotorSel,
hudakz 0:7a702d2d6b54 133 uint8_t leftRotorPos,
hudakz 0:7a702d2d6b54 134 uint8_t middleRotorPos,
hudakz 2:ee55abc2b6a2 135 uint8_t rightRotorPos,
hudakz 2:ee55abc2b6a2 136 uint8_t (*plugboard)[2],
hudakz 2:ee55abc2b6a2 137 uint8_t cords
hudakz 0:7a702d2d6b54 138 ) :
hudakz 0:7a702d2d6b54 139 _len(256),
hudakz 0:7a702d2d6b54 140 _leftRotorPos(leftRotorPos),
hudakz 0:7a702d2d6b54 141 _middleRotorPos(middleRotorPos),
hudakz 2:ee55abc2b6a2 142 _rightRotorPos(rightRotorPos),
hudakz 2:ee55abc2b6a2 143 _cords(cords)
hudakz 0:7a702d2d6b54 144 {
hudakz 0:7a702d2d6b54 145 // Initialize entry wheel.
hudakz 0:7a702d2d6b54 146 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 147 _entryWheel[i] = i;
hudakz 0:7a702d2d6b54 148 }
hudakz 0:7a702d2d6b54 149
hudakz 1:a21920e248d3 150 // Select three rotors out of fives.
hudakz 0:7a702d2d6b54 151 _leftRotor = const_cast<uint8_t*>(leftRotorSel);
hudakz 0:7a702d2d6b54 152 _middleRotor = const_cast<uint8_t*>(middleRotorSel);
hudakz 0:7a702d2d6b54 153 _rightRotor = const_cast<uint8_t*>(rightRotorSel);
hudakz 0:7a702d2d6b54 154
hudakz 1:a21920e248d3 155 // Initialize reflector.
hudakz 0:7a702d2d6b54 156 _reflector = const_cast<uint8_t*>(REFLECTOR);
hudakz 2:ee55abc2b6a2 157
hudakz 3:9590c44c9ecd 158 // Connect the plugboard
hudakz 2:ee55abc2b6a2 159 _plugboard = new uint8_t[cords][2];
hudakz 2:ee55abc2b6a2 160 for (size_t i = 0; i < cords; i++) {
hudakz 2:ee55abc2b6a2 161 for (size_t j = 0; j < 2; j++) {
hudakz 2:ee55abc2b6a2 162 _plugboard[i][j] = plugboard[i][j];
hudakz 2:ee55abc2b6a2 163 }
hudakz 2:ee55abc2b6a2 164 }
hudakz 0:7a702d2d6b54 165 }
hudakz 0:7a702d2d6b54 166
hudakz 0:7a702d2d6b54 167 /**
hudakz 1:a21920e248d3 168 * @brief Encrypts a byte array.
hudakz 4:107a360171fe 169 * @note It's capable to encrypt any byte, not only the 26 capital letters of the alphabet.
hudakz 1:a21920e248d3 170 * @retval out Pointer to a byte array to store the encrypted bytes in.
hudakz 1:a21920e248d3 171 * @param in Pointer to a byte array to be encrypted.
hudakz 1:a21920e248d3 172 * @param len Length of the byte array.
hudakz 3:9590c44c9ecd 173 * @retval Pointer to a byte array containing the encrypted bytes.
hudakz 0:7a702d2d6b54 174 */
hudakz 1:a21920e248d3 175 uint8_t* Enigma::encrypt(uint8_t* out, const uint8_t* in, size_t len)
hudakz 0:7a702d2d6b54 176 {
hudakz 2:ee55abc2b6a2 177 bool found;
hudakz 2:ee55abc2b6a2 178
hudakz 0:7a702d2d6b54 179 // Sets initial permutation
hudakz 0:7a702d2d6b54 180 int leftRotorPos = _leftRotorPos;
hudakz 0:7a702d2d6b54 181 int middleRotorPos = _middleRotorPos;
hudakz 0:7a702d2d6b54 182 int rightRotorPos = _rightRotorPos;
hudakz 0:7a702d2d6b54 183
hudakz 0:7a702d2d6b54 184 for (size_t i = 0; i < len; i++) {
hudakz 1:a21920e248d3 185 uint8_t byte = in[i];
hudakz 0:7a702d2d6b54 186
hudakz 3:9590c44c9ecd 187 // Swap bytes cross-connected with cords
hudakz 2:ee55abc2b6a2 188 found = false;
hudakz 2:ee55abc2b6a2 189 for (size_t j = 0; j < _cords; j++) {
hudakz 2:ee55abc2b6a2 190 for (size_t k = 0; k < 2; k++) {
hudakz 2:ee55abc2b6a2 191 if (_plugboard[j][k] == byte) {
hudakz 2:ee55abc2b6a2 192 byte = k == 0 ? _plugboard[j][1] : _plugboard[j][0];
hudakz 2:ee55abc2b6a2 193 found = true;
hudakz 2:ee55abc2b6a2 194 break;
hudakz 2:ee55abc2b6a2 195 }
hudakz 2:ee55abc2b6a2 196 }
hudakz 2:ee55abc2b6a2 197 if (found) {
hudakz 2:ee55abc2b6a2 198 break;
hudakz 2:ee55abc2b6a2 199 }
hudakz 2:ee55abc2b6a2 200 }
hudakz 2:ee55abc2b6a2 201
hudakz 1:a21920e248d3 202 // Advance right rotor on every byte entry
hudakz 0:7a702d2d6b54 203 rightRotorPos = _mod(rightRotorPos + 1);
hudakz 0:7a702d2d6b54 204
hudakz 1:a21920e248d3 205 // Avance mid rotor using a notch located at position #13
hudakz 0:7a702d2d6b54 206 if ((rightRotorPos % 13) == 0) {
hudakz 0:7a702d2d6b54 207 middleRotorPos = _mod(middleRotorPos + 2);
hudakz 0:7a702d2d6b54 208 }
hudakz 0:7a702d2d6b54 209
hudakz 2:ee55abc2b6a2 210 // Advance left rotor using a notch located at position #201
hudakz 2:ee55abc2b6a2 211 if ((middleRotorPos % 201) == 0) {
hudakz 0:7a702d2d6b54 212 leftRotorPos = _mod(leftRotorPos + 1);
hudakz 0:7a702d2d6b54 213 }
hudakz 0:7a702d2d6b54 214
hudakz 0:7a702d2d6b54 215 // Pass through rotors
hudakz 1:a21920e248d3 216 byte = _rightRotor[_mod(byte + rightRotorPos)];
hudakz 1:a21920e248d3 217 byte = _middleRotor[_mod(byte + middleRotorPos - rightRotorPos)];
hudakz 1:a21920e248d3 218 byte = _leftRotor[_mod(byte + leftRotorPos - middleRotorPos)];
hudakz 0:7a702d2d6b54 219
hudakz 0:7a702d2d6b54 220 // Pass through reflector
hudakz 1:a21920e248d3 221 byte = _reflector[_mod(byte - leftRotorPos)];
hudakz 1:a21920e248d3 222 byte = _entryWheel[_mod(byte + leftRotorPos)];
hudakz 0:7a702d2d6b54 223
hudakz 0:7a702d2d6b54 224 // Inverse pass trough rotors
hudakz 1:a21920e248d3 225 byte = _entryWheel[_mod(_find(byte, _leftRotor) - leftRotorPos + middleRotorPos)];
hudakz 1:a21920e248d3 226 byte = _entryWheel[_mod(_find(byte, _middleRotor) - middleRotorPos + rightRotorPos)];
hudakz 1:a21920e248d3 227 byte = _entryWheel[_mod(_find(byte, _rightRotor) - rightRotorPos)];
hudakz 0:7a702d2d6b54 228
hudakz 3:9590c44c9ecd 229 // Swap bytes cross-connected with cords
hudakz 2:ee55abc2b6a2 230 found = false;
hudakz 2:ee55abc2b6a2 231 for (size_t j = 0; j < _cords; j++) {
hudakz 2:ee55abc2b6a2 232 for (size_t k = 0; k < 2; k++) {
hudakz 2:ee55abc2b6a2 233 if (_plugboard[j][k] == byte) {
hudakz 2:ee55abc2b6a2 234 byte = k == 0 ? _plugboard[j][1] : _plugboard[j][0];
hudakz 2:ee55abc2b6a2 235 found = true;
hudakz 2:ee55abc2b6a2 236 break;
hudakz 2:ee55abc2b6a2 237 }
hudakz 2:ee55abc2b6a2 238 }
hudakz 2:ee55abc2b6a2 239 if (found) {
hudakz 2:ee55abc2b6a2 240 break;
hudakz 2:ee55abc2b6a2 241 }
hudakz 2:ee55abc2b6a2 242 }
hudakz 2:ee55abc2b6a2 243
hudakz 1:a21920e248d3 244 out[i] = byte;
hudakz 0:7a702d2d6b54 245 }
hudakz 0:7a702d2d6b54 246
hudakz 0:7a702d2d6b54 247 return out;
hudakz 0:7a702d2d6b54 248 }
hudakz 0:7a702d2d6b54 249
hudakz 0:7a702d2d6b54 250 /**
hudakz 1:a21920e248d3 251 * @brief Decrypts a byte array.
hudakz 4:107a360171fe 252 * @note It's capable to encrypt any byte, not only the 26 capital letters of the alphabet.
hudakz 1:a21920e248d3 253 * @retval out Pointer to a byte array to store the decrypted bytes in.
hudakz 1:a21920e248d3 254 * @param in Pointer to a byte array to be decrypted.
hudakz 1:a21920e248d3 255 * @param len Length of the byte array.
hudakz 3:9590c44c9ecd 256 * @retval Pointer to a byte array containing the decrypted bytes.
hudakz 0:7a702d2d6b54 257 */
hudakz 1:a21920e248d3 258 uint8_t* Enigma::decrypt(uint8_t* out, const uint8_t* in, size_t len)
hudakz 0:7a702d2d6b54 259 {
hudakz 0:7a702d2d6b54 260 return encrypt(out, in, len);
hudakz 0:7a702d2d6b54 261 }
hudakz 0:7a702d2d6b54 262
hudakz 0:7a702d2d6b54 263 /**
hudakz 0:7a702d2d6b54 264 * @brief Generates a new rotor wiring.
hudakz 1:a21920e248d3 265 * @note Prints to the serial terminal. The generated byte array
hudakz 1:a21920e248d3 266 * shall be then copy & pasted to his source code and recompiled.
hudakz 0:7a702d2d6b54 267 * @param name Rotor's name. Should be "I", "II", "III", "IV" or "V"
hudakz 0:7a702d2d6b54 268 * @param seed A number to seed the pseudo-ramdom generator with.
hudakz 0:7a702d2d6b54 269 * @retval
hudakz 0:7a702d2d6b54 270 */
hudakz 0:7a702d2d6b54 271 void Enigma::genRotorWiring(const char* name, unsigned seed)
hudakz 0:7a702d2d6b54 272 {
hudakz 0:7a702d2d6b54 273 uint8_t* rotor = new uint8_t[_len];
hudakz 0:7a702d2d6b54 274 srand(seed);
hudakz 0:7a702d2d6b54 275 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 276 rotor[i] = i;
hudakz 0:7a702d2d6b54 277 }
hudakz 0:7a702d2d6b54 278 for (int j = 0; j < (rand() % 1000 + 1000); j++) {
hudakz 0:7a702d2d6b54 279 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 280 uint8_t byte = rotor[i];
hudakz 0:7a702d2d6b54 281 int k = rand() % _len;
hudakz 0:7a702d2d6b54 282 rotor[i] = rotor[k];
hudakz 0:7a702d2d6b54 283 rotor[k] = byte;
hudakz 0:7a702d2d6b54 284 }
hudakz 0:7a702d2d6b54 285 }
hudakz 0:7a702d2d6b54 286
hudakz 0:7a702d2d6b54 287 printf("const uint8_t Enigma::ROTOR_%s[256] = {\r\n", name);
hudakz 0:7a702d2d6b54 288 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 289 if (i == 255) {
hudakz 4:107a360171fe 290 printf("0x%.2X\r\n", rotor[i]);
hudakz 0:7a702d2d6b54 291 }
hudakz 0:7a702d2d6b54 292 else {
hudakz 0:7a702d2d6b54 293 switch (i % 16) {
hudakz 0:7a702d2d6b54 294 case 0:
hudakz 4:107a360171fe 295 printf(" 0x%.2X, ", rotor[i]);
hudakz 0:7a702d2d6b54 296 break;
hudakz 0:7a702d2d6b54 297
hudakz 0:7a702d2d6b54 298 case 15:
hudakz 4:107a360171fe 299 printf("0x%.2X,\r\n", rotor[i]);
hudakz 0:7a702d2d6b54 300 break;
hudakz 0:7a702d2d6b54 301
hudakz 0:7a702d2d6b54 302 default:
hudakz 4:107a360171fe 303 printf("0x%.2X, ", rotor[i]);
hudakz 0:7a702d2d6b54 304 }
hudakz 0:7a702d2d6b54 305 }
hudakz 0:7a702d2d6b54 306 }
hudakz 0:7a702d2d6b54 307
hudakz 0:7a702d2d6b54 308 printf("};\r\n\r\n");
hudakz 0:7a702d2d6b54 309
hudakz 0:7a702d2d6b54 310 delete[] rotor;
hudakz 0:7a702d2d6b54 311 }
hudakz 0:7a702d2d6b54 312
hudakz 0:7a702d2d6b54 313 /**
hudakz 0:7a702d2d6b54 314 * @brief Generates a reflector wiring.
hudakz 1:a21920e248d3 315 * @note Prints to the serial terminal. The generated byte array
hudakz 1:a21920e248d3 316 * shall be then copy & pasted to his source code and recompiled.
hudakz 0:7a702d2d6b54 317 * @param seed A number to seed the pseudo-ramdom generator with.
hudakz 0:7a702d2d6b54 318 * @retval
hudakz 0:7a702d2d6b54 319 */
hudakz 0:7a702d2d6b54 320 void Enigma::genReflectorWiring(unsigned seed)
hudakz 0:7a702d2d6b54 321 {
hudakz 0:7a702d2d6b54 322 uint8_t* reflector = new uint8_t[_len];
hudakz 0:7a702d2d6b54 323 uint8_t* modified = new uint8_t[_len];
hudakz 0:7a702d2d6b54 324 size_t k;
hudakz 0:7a702d2d6b54 325
hudakz 0:7a702d2d6b54 326 srand(seed);
hudakz 0:7a702d2d6b54 327 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 328 reflector[i] = i;
hudakz 0:7a702d2d6b54 329 }
hudakz 0:7a702d2d6b54 330
hudakz 0:7a702d2d6b54 331 memset(modified, 0, _len);
hudakz 0:7a702d2d6b54 332
hudakz 0:7a702d2d6b54 333 for (size_t i = 0; i < _len; i++) {
hudakz 3:9590c44c9ecd 334
hudakz 0:7a702d2d6b54 335 if (modified[i] != 0) {
hudakz 3:9590c44c9ecd 336
hudakz 3:9590c44c9ecd 337
hudakz 0:7a702d2d6b54 338 continue;
hudakz 0:7a702d2d6b54 339 }
hudakz 0:7a702d2d6b54 340
hudakz 0:7a702d2d6b54 341 do {
hudakz 0:7a702d2d6b54 342 k = i + 1 + rand() % (_len - i - 1);
hudakz 0:7a702d2d6b54 343 } while (modified[k]);
hudakz 0:7a702d2d6b54 344
hudakz 0:7a702d2d6b54 345 uint8_t byte = reflector[k];
hudakz 0:7a702d2d6b54 346 reflector[k] = reflector[i];
hudakz 0:7a702d2d6b54 347 reflector[i] = byte;
hudakz 0:7a702d2d6b54 348 modified[i] = 1;
hudakz 0:7a702d2d6b54 349 modified[k] = 1;
hudakz 0:7a702d2d6b54 350 }
hudakz 0:7a702d2d6b54 351
hudakz 0:7a702d2d6b54 352 delete[] modified;
hudakz 0:7a702d2d6b54 353
hudakz 0:7a702d2d6b54 354 printf("const uint8_t Enigma::REFLECTOR[256] = {\r\n");
hudakz 0:7a702d2d6b54 355 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 356 if (i == 255) {
hudakz 4:107a360171fe 357 printf("0x%.2X\r\n", reflector[i]);
hudakz 0:7a702d2d6b54 358 }
hudakz 0:7a702d2d6b54 359 else {
hudakz 0:7a702d2d6b54 360 switch (i % 16) {
hudakz 0:7a702d2d6b54 361 case 0:
hudakz 4:107a360171fe 362 printf(" 0x%.2X, ", reflector[i]);
hudakz 0:7a702d2d6b54 363 break;
hudakz 0:7a702d2d6b54 364
hudakz 0:7a702d2d6b54 365 case 15:
hudakz 4:107a360171fe 366 printf("0x%.2X,\r\n", reflector[i]);
hudakz 0:7a702d2d6b54 367 break;
hudakz 0:7a702d2d6b54 368
hudakz 0:7a702d2d6b54 369 default:
hudakz 4:107a360171fe 370 printf("0x%.2X, ", reflector[i]);
hudakz 0:7a702d2d6b54 371 }
hudakz 0:7a702d2d6b54 372 }
hudakz 0:7a702d2d6b54 373 }
hudakz 0:7a702d2d6b54 374
hudakz 0:7a702d2d6b54 375 printf("};\r\n\r\n");
hudakz 0:7a702d2d6b54 376
hudakz 0:7a702d2d6b54 377 delete[] reflector;
hudakz 0:7a702d2d6b54 378 }
hudakz 0:7a702d2d6b54 379
hudakz 0:7a702d2d6b54 380 /**
hudakz 0:7a702d2d6b54 381 * @brief
hudakz 0:7a702d2d6b54 382 * @note
hudakz 0:7a702d2d6b54 383 * @param
hudakz 0:7a702d2d6b54 384 * @retval
hudakz 0:7a702d2d6b54 385 */
hudakz 0:7a702d2d6b54 386 size_t Enigma::_mod(long i)
hudakz 0:7a702d2d6b54 387 {
hudakz 0:7a702d2d6b54 388 return((i % _len + _len) % _len);
hudakz 0:7a702d2d6b54 389 }
hudakz 0:7a702d2d6b54 390
hudakz 0:7a702d2d6b54 391 /**
hudakz 0:7a702d2d6b54 392 * @brief
hudakz 0:7a702d2d6b54 393 * @note
hudakz 0:7a702d2d6b54 394 * @param
hudakz 0:7a702d2d6b54 395 * @retval
hudakz 0:7a702d2d6b54 396 */
hudakz 0:7a702d2d6b54 397 int Enigma::_find(uint8_t byte, uint8_t* array)
hudakz 0:7a702d2d6b54 398 {
hudakz 0:7a702d2d6b54 399 for (size_t i = 0; i < _len; i++) {
hudakz 0:7a702d2d6b54 400 if (array[i] == byte) {
hudakz 0:7a702d2d6b54 401 return i;
hudakz 0:7a702d2d6b54 402 }
hudakz 0:7a702d2d6b54 403 }
hudakz 0:7a702d2d6b54 404
hudakz 0:7a702d2d6b54 405 return -1;
hudakz 3:9590c44c9ecd 406 }