# Pillar 6

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Pillar 6 in daytime

Pillar 6 contains a dot-dash cipher (Solved), a series of Enigma-style rotor scrambling wheels, two lines of alpha text (Unsolved) and a series of numbers around the bottom which probably form part of a cipher (Unsolved).

Pillar 6 is 2153mm tall and is the sixth tallest of the eight pillars.

## Dot Dash Grid - Solved

Large view of the Dot Dash Grid

The grid is represented in dots and dashes, the best way to represent it is in binary, with a 1 for a dash and a 0 for a dot.

 1000100000101000110011011001011001001001011010011110 1100011111100010001011111000000011110100000010110000 0010000000000010101000000000100000001000100010000000 1111111111001110100010011001011010001001101110100010 0111110011011001001000000010000001100000101111101010 0000000000001010000000100000100010000010100000000000 1000111001100111100111110010011110110100101100100110 0111101000100010011110001010001010111110100011001000 0000100000001000000000101010100000000010001000001000 1101011000001010011010101011111101100000100011110001 1110001001101000001011111011001011011111010100001000 0000100000101000100000000000100000000000000000100010 1101111001101111001001011000100100011010011111011010 1100001000100000011011000101100010011100000011110111 0010100010101010000000101000001010100000100000000000

A solution given by Glenn McIntosh on the Nkrypt Facebook page in the wee hours of 11 March 2013 is as follows:

 Each character is encoded as a 2x3 array of bits, with low order bits at the top. The bit order in each 2x3 array is: 01 23 45 This gives a text output (though you have to traverse it labyrinth style): MPILLEATSTONEBRANLYBRAUNCA KOOCOHWYADARAFRAYDARUOMEDE ILWEBERGINGSTURGEONTESLAVA OFREHTUAREMMEOSGNILLIHCSDR ORSERUSSHENRYHERTZMARCONIM The plaintext is a list of scientists and inventors, who worked on electrical telegraphy and wireless telegraphy. Starting centre top: "Branly, Braun, Campillo, Cooke, DeMoura, Dyar, Faraday, Gauss, Henry, Hertz, Marconi, Morse, Rutherford, Schilling, Soemmering, Sturgeon, Tesla, Vail, Weber, Wheatstone"

## Rotor Wheels

drawing of rotor patterns

The pillar has four Enigma-style rotor wheels, and one reflector wheel. Above the first rotor wheel is the alphabet. The four rotor wheels move freely between incremental stops. The reflector wheel is fixed in position. Each wheel (including reflector) has triangular markings that can be aligned, presumably to indicate a starting rotor position.

Rotor wiring was determined by visiting the sculpture and following each "wire" with a fingernail, and marking where it terminated. I was quite diligent to get it right, and I did run a few checks after typing it all out that seem to indicate that they're correct (no duplicates etc) - but there's always a chance I have it wrong.

Rotor 1 "wiring"

 ABCDEFGHIJKLMNOPQRSTUVWXYZ UDBCFGEJHILMKTSNOPQRWXYZAV

Rotor 2 "wiring"

 ABCDEFGHIJKLMNOPQRSTUVWXYZ BZCXWHIFGLMJKVUPSQRTONEDYA

Rotor 3 "wiring"

Rotor 4 "wiring"

 ABCDEFGHIJKLMNOPQRSTUVWXYZ BDFCEGIJKLSMAZNHOPQRTVXUWY

Reflector "wiring"

 ABCDEFGJNOPSVW ZYVMLIHKURQTCX

Reflector "wiring" with duplicates/pairs

 ABCDEFGHIJKLMNOPQRSTUVWXYZ ZYVMLIHGFKJEDURQPOTSNCXWBA

Stuart K writes "NKYPT's Version obviously has two real differences to its WWII inspiration. one is the wiring pattern is not secret and is fixed in order and orientation - making that part of the coding processes much much weaker.. BUT becasue the rotors can be advanced/retarded in any sequence - simple, arbitary, algorithmically, or randomly it can none the less be the basis of a much stronger code, AND could be used as the platform for any number of encoding approaches. AND (in case that wasn't enough) -- the starting position of the various rotors could be set to any arbitary initial configuration."

```// NKRYPT enigma implementation
// compilation: g++ -O3 -std=c++11 -c en.cpp
// include files
#include <cstddef>
#include <cstdint>
// definitions
const size_t N = 26;
// enigma engine
class Enigma
{
public:
// initialize rotor tables
Enigma();
// set rotor positions
void set(uint8_t s1, uint8_t s2, uint8_t s3, uint8_t s4);
void rot(int8_t i1, int8_t i2, int8_t i3, int8_t i4);
// encrypt
uint8_t en(uint8_t c) const;
private:
// rotors
uint8_t r1d[N], r2d[N], r3d[N], r4d[N];
uint8_t r5r[N];
uint8_t r4u[N], r3u[N], r2u[N], r1u[N];
// setting
uint8_t o1, o2, o3, o4;
};
// initialize rotor tables
Enigma::Enigma()
{
for (size_t i = 0; i < N; ++i)
{
r1d[i] = "udbcfgejhilmktsnopqrwxyzav"[i]-'a';
r2d[i] = "bzcxwhifglmjkvupsqrtonedya"[i]-'a';
r4d[i] = "bdfcegijklsmaznhopqrtvxuwy"[i]-'a';
r5r[i] = "zyvmlihgfkjedurqpotsncxwba"[i]-'a';
r3u[i] = "bxgcdefhjklmirnopqtuvwsyza"[i]-'a';
r2u[i] = "zacxwhifglmjkvuprsqtonedyb"[i]-'a';
r1u[i] = "ycdbgefijhmklpqrstonazuvwx"[i]-'a';
}
o1 = o2 = o3 = o4 = 0;
}
// set rotor position
void Enigma::set(uint8_t s1, uint8_t s2, uint8_t s3, uint8_t s4)
{
o1 = s1;
o2 = s2;
o3 = s3;
o4 = s4;
}
// rotate rotor position
void Enigma::rot(int8_t i1, int8_t i2, int8_t i3, int8_t i4)
{
// increment
o1 += i1+N; o1 %= N;
o2 += i2+N; o2 %= N;
o3 += i3+N; o3 %= N;
o4 += i4+N; o4 %= N;
}
// encrypt/decrypt
uint8_t Enigma::en(uint8_t c) const
{
c -= 'A';
c += N-o1; c = r1d[c%N]; c += o1;
c += N-o2; c = r2d[c%N]; c += o2;
c += N-o3; c = r3d[c%N]; c += o3;
c += N-o4; c = r4d[c%N]; c += o4;
c = r5r[c%N];
c += N-o4; c = r4u[c%N]; c += o4;
c += N-o3; c = r3u[c%N]; c += o3;
c += N-o2; c = r2u[c%N]; c += o2;
c += N-o1; c = r1u[c%N]; c += o1;
c %= N;
c += 'a';
return c;
}

```

## Alphabetic code

There are two lines of text below the rotor wheels. They read:

 DL BIOB AXQC NLPA MNXE SBNT FJLD KH JAWS FDHD MATX EJHM PVUJ XJOM

## Base

A string of numbers run in a circular pattern around the base of each pillar (see notes on the base code). On this pillar, it reads:

 10 10 11 12 11 13 14 15 30 30 17 18 12 12 8 10 14 14 19 22 12 12 11 13 7 7 8 8 14 17