TDD-Deciphered.com

« Previous: Part 9: Implementing the real rotors

Next: Part 11: The final pieces, and a real decrypt »

Part 10: Assembling the Machine

01/02/2010

There are still two electrical elements of the system we've not simulated; the reflector and the plugboard. Both of these, as mentioned above, will implement Enigma_Encryptor_Interface.

The reflector is extremely simple, and we can implement it in a simpler version of the technique we used for the wheels:

Enigma_Reflector_Abstract sets up the basics and implements the required getOutputCharacterForInputCharacter function, and the concrete implementations Enigma_Reflector_B and Enigma_Reflector_C will include the mapping data, which we can again find at http://www.codesandciphers.org.uk/enigma/rotorspec.htm

We'll go back to writing tests first, with the folloiwing in a new ReflectorTest.php file:

<?php
 
require_once ('../../library/initialise.php');
 
class Enigma_ReflectorTest extends PHPUnit_Framework_TestCase
{
    /**
     *
     * @param $rotor Enigma_Reflector_Abstract
     * @param $in
     * @param $out
     * @dataProvider rotorMappingsDataProvider
     */
    function testVariousMappings(Enigma_Reflector_Abstract $rotor, $in,$out)
    {
        $this->assertSame($out,$rotor->getOutputCharacterForInputCharacter($in));
    }
 
    function rotorMappingsDataProvider()
    {
        return array(
        array(new Enigma_Reflector_B, 'B', 'R'),
        array(new Enigma_Reflector_B, 'O', 'M'),
        array(new Enigma_Reflector_C, 'M', 'X'),
        array(new Enigma_Reflector_C, 'R', 'K'),
        );
    }
 
}

and quickly build Enigma_Reflector_Abstract:

<?php
abstract class Enigma_Reflector_Abstract implements Enigma_Encryptor_Interface
{
    protected $_halfMapping=array();
    protected $_fullMapping=null;
 
    public function __construct()
    {
        if(is_null($this->_fullMapping)) {
            $this->_fullMapping=$this->_halfMapping+array_flip($this->_halfMapping);
        }
    }
 
    public function getOutputCharacterForInputCharacter ($inputCharacter) {
        $inputCharacter=strtoupper($inputCharacter);
        if (isset($this->_fullMapping[$inputCharacter])) {
            return ($this->_fullMapping[$inputCharacter]);
        } else {
            throw new Exception('Invalid reflector input');
        }
    }
}

and the B and C classes

<?php
class Enigma_Reflector_B extends Enigma_Reflector_Abstract
{
    protected $_halfMapping=array('A'=>'Y', 'B'=>'R', 'C'=>'U', 'D'=>'H', 'E'=>'Q', 'F'=>'S',
        'G'=>'L', 'I'=>'P', 'J'=>'X', 'K'=>'N', 'M'=>'O', 'T'=>'Z', 'V'=>'W');
}

<?php
class Enigma_Reflector_C extends Enigma_Reflector_Abstract
{
    protected $_halfMapping=array('A'=>'F', 'B'=>'V', 'C'=>'P', 'D'=>'J', 'E'=>'I', 'G'=>'O',
    'H'=>'Y', 'K'=>'R', 'L'=>'Z', 'M'=>'X', 'N'=>'W', 'T'=>'Q', 'S'=>'U',
    );
}

Again, as the tests run, we can trust our mapping.

Now we can start thinking about how these elements can be put together to form a complete encoding device. This device will be 3 rotors, 1 reflector, no plugboard.

We need to build 3 slots, and put a configured rotor in each. We set each slot to observe the slot to the right to handle the mechanical phase. We add a reflector.

When we press each button:

We trigger the mechanical phase by calling the rightmost slot's incrementRotorOffset() function. This then causes any required rollovers.

In the electrical phase, we take an input character and pass it to the input of the first rotor slot, which then routes it via the rotor to its output.

We take that output signal and feed it through the middle slot.

We take that output signal and feed it through the rightmost slot.

We take that output signal and feed it through the reflector.

We then feed the signal backwards through the rotors in turn.

Ah - problem - we've not specified a way to send signals backwards through an asymmetric encryptor like the rotor wheel. In fact we've not really considered the fact that the rotors (and therefore the slots) are asymmetric.

We can solve this quite simply with a new function of getOutputCharacterForInputCharacterReverse, which we'll enforce in the slots and rotors as a new interface: Enigma_Encryptor_Asymmetric_Interface:

<?php
interface Enigma_Encryptor_Asymmetric_Interface extends Enigma_Encryptor_Interface
{
    public function getOutputCharacterForInputCharacterReverse ($inputCharacter);
}

and we can replace Enigma_Encryptor_Interface with the new extended interface in Enigma_Rotor_Abstract and Enigma_RotorSlot.

If we run our tests now, we'll get complaints about the missing functions, so we add these:

In Enigma_RotorSlot:

public function getOutputCharacterForInputCharacterReverse ($inputCharacter)
    {
        $inputCharacter = strtoupper($inputCharacter);
 
 
        $rotorInputCharacter = $this->_getCharacterOffsetBy($inputCharacter, $this->_rotorOffset-1);
 
        $rotorOutputCharacter = $this->_rotor->getOutputCharacterForInputCharacterReverse(
        $rotorInputCharacter
        );
 
        $outputCharacter = $this->_getCharacterOffsetBy(
        $rotorOutputCharacter, 0 - ($this->_rotorOffset -1)
        );
 
        return ($outputCharacter);
    }

and in Enigma_Rotor_Abstract:

public function getOutputCharacterForInputCharacterReverse ($inputCharacter)
    {
        $inputCharacter = strtoupper($inputCharacter);
        $coreInputCharacter = $this->_getCharacterOffsetBy($inputCharacter, $this->_ringOffset - 1);
 
        $flipMap=array_flip($this->_coreMapping);
 
        $coreOutputCharacter = $flipMap[$coreInputCharacter];
        $outputCharacter = $this->_getCharacterOffsetBy(
        $coreOutputCharacter, 0 - ($this->_ringOffset -1)
        );
 
        return ($outputCharacter);
    }

Note that all that's happening inside here is that we're flipping the rotor's mapping array when we route the signal through it.

Again, our tests run cleanly; check in (rev 11)!

Now we have all the parts we need to build an Enigma machine (remembering that not all types of Enigma had plugboards, and those that have them could ignore them if required). As this is a character encoding device, we can re-use our interface, giving us:

class Enigma_Machine implements Enigma_Encryptor_Interface

To set up the machine, we need to specify and add its various components. Again, for the sake of speed, I'm not going to test all the setters and getters, but we have:

/**
     * Number of slots this machine has. Default to original three
     * 
     * @var int
     */
    protected $_numSlots=3;
 
    /**
     * Set of slots to house rotors
     *  
     * @var array of Enigma_RotorSlot
     */
    protected $_slots=array();
 
    /**
     * Space for reflector
     * 
     * @var Enigma_Reflector_Abstract
     */
    protected $_reflector;
 
    /**
     * Does this machine have a steckboard? Some don't
     *  
     * @var boolean
     */
    protected $_hasSteckerBoard=false;
 
    /**
     * Space for the steckerboard if we add one
     *  
     * @var Enigma_SteckerBoard
     */
    protected $_steckerBoard;

We can now assemble the machine in its constructor:

public function __construct()
    {
        if($this->_hasSteckerBoard)
        {   // Can implement this later!
            $this->_steckerBoard=new Enigma_SteckerBoard;
        }
 
        for($i=0; $i<$this->_numSlots;$i++) {
            $this->_slots[$i]=new Enigma_RotorSlot;
            if($i>0) { //higher slots watch lower ones
                $this->_slots[$i-1]->registerTurnoverObserver($this->_slots[$i]);
            }
        }
    }

and build the configuration methods:

public function setRotors($rotors)
    {
        if(!(is_array($rotors) && ($this->_numSlots==count($rotors))))
        {
            throw new Exception("Rotors must be $this->_numSlots-element array");
        }
 
        $i=0;
        foreach($rotors as $rotor)
        {
            if(!$rotor instanceof Enigma_Rotor_Abstract) {
                throw new Exception('Slots can only be loaded with Enigma_Rotor_* class');
            }
 
            $this->_slots[$i]->loadRotor($rotor);
            $i++;
        }
    }
 
    public function setRotorStartPositions($positions)
    {
        if(!(is_array($positions) && ($this->_numSlots==count($positions))))
        {
            throw new Exception("Rotor positions must be $this->_numSlots-element array");
        }
 
        $i=0;
        foreach($positions as $position)
        {
            $this->_slots[$i]->setRotorOffset($position);
            $i++;
        }
    }
 
    public function setReflector(Enigma_Reflector_Abstract $reflector)
    {
        $this->_reflector=$reflector;
    }
 
 
    public function getOutputCharacterForInputCharacter ($inputCharacter)
    {
        if(!$this->_isFullyBuilt()) {
            throw new Exception('Device not fully built');
        }
 
        //We'll trigger the mechanical phase here as we can't send a signal without doing so
        //(ok, strictly there's a hardware hack)
        $this->_slots[0]->incrementRotorOffset();
 
        $char=$inputCharacter;
 
        //line up our coding stages and feed the signal through them:
 
        if($this->_hasSteckerBoard) {
            $char=$this->_steckerBoard->getOutputCharacterForInputCharacter($char);
        }
 
        //rotors inbound
        foreach($this->_slots as $slot)
        {
            $char=$slot->getOutputCharacterForInputCharacter($char);
        }
 
        // through the reflector:
        $char=$this->_reflector->getOutputCharacterForInputCharacter($char);
 
        //rotors outbound (current flows other way)
        for($i=$this->_numSlots-1;$i>=0;$i--)
        {
            $slot=$this->_slots[$i];
            $char=$slot->getOutputCharacterForInputCharacterReverse($char);
        }
 
        //steckers are symmetrical
        if($this->_hasSteckerBoard) {
            $char=$this->_steckerBoard->getOutputCharacterForInputCharacter($char);
        }
 
        return($char);
 
    }
 
    /**
     *
     * @return Enigma_SteckerBoard
     */
    public function getSteckerBoard()
    {
        return($this->_steckerBoard);
    }
 
    protected function _isFullyBuilt()
    {
        //for now, lie.
        return true;
    }

Now, we have enough code to directly simulate a (basic) Engima encoder – but how can we use and test it?

Ideally, we'd test some input data and some known conditions against some known output data. The question is – do we have any such data?

Unfortunately not. It's extremely hard to find sample encrypts online, especially messages that have been encrypted with no plugboard, so we have no direct comparison data.

One test we can do is to check the device's symmetrical properties. If we encipher a message with known settings, then take that output and put it back through the same device with the same start settings, then we should recover our original message.

We'll do this with a test rig first rather than a unit test, as there's a lot of setup to do that we've not yet fully implemented; as mentioned above, this would be the duty of our 'Enigma_Signaller' class.

Our script (in cli/testRig.php) looks like:

<?php
require_once ('../library/initialise.php');
 
$messageString='Action This Day';
 
$messageArray=preg_split('//',$messageString);
 
$messageArrayClean=array();
foreach($messageArray as $char) {
    if(preg_match('/[a-z]/i',$char)) {
        $messageArrayClean[]=strtoupper($char);
    }
}
 
$device=new Enigma_Machine();
 
$rotors=array();
$rotors[0]=new Enigma_Rotor_I;
$rotors[0]->setRingOffset('C');
$rotors[1]=new Enigma_Rotor_II;
$rotors[1]->setRingOffset('A');
$rotors[2]=new Enigma_Rotor_III;
$rotors[2]->setRingOffset('A');
 
$device->setRotors($rotors);
$device->setRotorStartPositions(array('P','A','A'));
 
$reflector=new Enigma_Reflector_B;
 
$device->setReflector($reflector);
 
echo ("\n".join('',$messageArrayClean)."\n\n");
 
foreach ($messageArrayClean as $char)
{
        $char=$device->getOutputCharacterForInputCharacter($char);
 
        echo $char;
 
}
echo ("\n\n");

One caveat to add here is that our rotors are numbered right-to-left, because that's the order of incoming signal and turnover. Therefore a key setting of 'AAP' (as it might be written in a key sheet or discussion of the machine) is applied as $device->setRotorStartPositions(array('P','A','A'));

The script also gives us the chance to discuss how the machine was used. We won't try and apply any of the German security practices yet, but we'll take a simple, short message, and encode it.

Our test message is 'Action This Day'. This was the phrase with which Churchill ordered that Bletchley Park was to have "all necessary support" [CHECK QUOTE] after being informed by its departmental heads in a very irregular letter that it was starved of resources. As such it reflects both the recognition of Bletchley's importance and the point at which it began to realise its full potential.

To encode this message, we have to convert it to a format which the Enigma can accept. This means upper-case letters only; no spaces, no punctuation. Plus, to get it into our machine's input, we'll need to split it into individual characters.

Spaces were often replaced with X's in Enigma messages – a procedure which turned out to be a weakness in the security policies, as it meant that 'X" was the most-used character in such messages, and made word breaks easier to find in decoded messages. For now, though, we'll just skip the spaces.

So, by 'standardising' the message 'Action This Day', we get an array of A,C,T,I,O,N,T,H,I,S,D,A,Y.

Once we've set our machine up as specified above, we run the command-line script:

$ php -q testRigWithDevice.php

ACTIONTHISDAY

DWOUFBIGODOGS

Now, I'm not sure where the canine fixation of this message happened to come from, but if we re-run this script with the encrypted form as our input, we'll see whether we're barking up the wrong tree. Edit the line

$messageString='Action This Day';

to

$messageString='DWOUFBIGODOGS';

and with luck we'll get our input back!

$ php -q testRigWithDevice.php

DWOUFBIGODOGS

ACTIONTHISDAY

It works! However, we still need to check it against a "real" message. If we encode the above message on a 'real' device, will we get the same results?

Well, sadly, I don't own a real Enigma machine (much as I'd love to) so we'll have to make do with a reference implementation. I used Terry Long's Enigma Simulator for OSX from http://www.terrylong.org/ to verify this message and it does indeed match the data above. We have a working machine! (so check in - r12!)

Next time, we'll add the final piece required to simulate most of the basic Enigma types - the Steckerboard - and look at deciphering some real wartime messages.

« Previous: Part 9: Implementing the real rotors

Index

Next: Part 11: The final pieces, and a real decrypt »

TDD-Deciphered.com

Part 10: Assembling the Machine

Navigation

Contact