View source for Enigma/enigma8.

<div class="Source" style="height:400px; overflow:auto">
<Source lang=c>
/**************************************************************************
  #     #
  ##   ##  ######  #####    ####     ##    #    #   #####  ######   ####
  # # # #  #       #    #  #    #   #  #   ##   #     #    #       #    #
  #  #  #  #####   #    #  #       #    #  # #  #     #    #####   #
  #     #  #       #####   #       ######  #  # #     #    #       #
  #     #  #       #   #   #    #  #    #  #   ##     #    #       #    #
  #     #  ######  #    #   ####   #    #  #    #     #    ######   ####

***************************************************************************
Author..: Henrik Thomsen heth@mercantec.dk
Company.: House of Technology at Mercantec ( http://www.mercantec.dk )
date....: 2010 Nov. 28
Version.: 0.00000000001 (Still experimental)
***************************************************************************
Abstract: Enigma8 is a symmetrical encryption/decryption engine developed
          and used for fun. DONT USE IT FOR ANY ACTUAL REAL-LIVE purpose
Purpose.: To be used for fun to challenge our students making multithreaded
          solutions to break the codes.
***************************************************************************
Cavets..: wheels and rotor reflectors made with program makewheel which:
                - Real lousy solution generating random numbers with rand()
                -Real lousy solution solving missing hits in sub rr. missing
                 randomness.

          This program was written in C after years of no C-coding, so
          the generel structure is quite messy. (Sorry ;o)
          It's purpose however is to challenge students so perhaps they
          will improve it.
***************************************************************************
Modification log:
***************************************************************************
License:  Free open software but WITHOUT ANY WARRANTY.
Terms..:  see http://www.gnu.org/licenses
**************************************************************************/
#include <errno.h>
#include <stdlib.h>
#include <sys/timeb.h>
#include <stdio.h>
#include "wheels.h"
#define WHEELSUSED 3

char *progname;
int order[WHEELSUSED] = {2,0,1}; /* Wheels installed and in which order */
int position[WHEELSUSED] = {10,216,65}; /* Inital position of rotors */

void usage( void ) {
        printf("Usage:\n%s from-file to-file\n",progname);
        printf("\n%s is a symmetrical encryption/decryption Enigma engine copy\n",progname);
        exit(1);
}
/* sub tick
  abstract: Wheel 1 is ticked forward after each byte.
             Alle wheels have a notch. When they reach their notch the whell
             will tick the next wheel. See wheel_notch in wheels.h
             When wheel 1 reaches its notch it will tick wheel 2 one
             tick forward. When wheel 2 reaches its notch it will tick
             wheel 3 one tick forward etc...
   input     None it uses global variables wheel_notch, order and
             postition.
   returns   none */
void tick( void ) {
        int i,j,flag;
        for (i=0; i < WHEELSUSED; i++ ) {
                if ( i == 0 ) {  /* First wheel always ticks */
                        position[0]++;
                        if ( position[0] >  255 ) { /* Wheel turn over */
                                position[0]=0;
                        }
                }
                if ( wheel_notch[order[i]] == position[i] ) { /* At notch */
                        if ( i < ( WHEELSUSED-1) ) { /* Last wheel dont tick next */
                                flag=1;
                                /* All preceding wheel at notch, then tick next*/
                                for (j=0; j <= i; j++ ) {
                                        if ( wheel_notch[order[j]] != position[j] ) {
                                                flag = 0;
                                        }
                                }
                                if ( flag == 1) {
                                        position[i+1]++;
                                        if ( position[i+1] > 255 ) {
                                                position[i+1] = 0; /* Wheel turn over */
                                        }
                                }
                        }
                }
        }
}

/* sub rotor
   abstract: Send data through a rotor
   input wh  = wheel number
         pos = position (how many ticks is the wheel rotated)
         n   = data (integer) sent through the wheel
   returns (integer) new value of n after been throgh the wheel*/
int rotor(int wh,int pos,int n) {
        /* Beregn den relative position når hjulet er roteret pso ticks */
        int rel;
        if ( n-pos < 0) {
                n+=256;
        }
        rel = wheel[wh][n-pos]+pos;
        if (rel > 255 ) {
                rel = rel % 256;
        }
        return(rel);
}

/* sub revrotor
   abstract: Send data through a reverse rotor (After Route Reflector)
   input wh  = wheel number
         pos = position (how many ticks is the wheel rotated)
         n   = data (integer) sent through the wheel
   returns (integer) new value of n after been throgh the reverse wheel*/
int revrotor(int wh,int pos,int n) {
        /* Beregn den relative position når hjulet er roteret pso ticks */
        int rel;
        if ( n-pos < 0) {
                n+=256;
        }
        rel = rwheel[wh][n-pos]+pos;
        if (rel > 255 ) {
                rel = rel % 256;
        }
        return(rel);
}

/* sub reflector
   abstract: Send data through the route reflector
    input n  = data (integer) sent through the route reflector
    output   = data (integer) after n has been through the route reflector*/
int reflector(int n) {
        return(rr[n]);
}
int main( int argc, char *argv[] ) {
        int c,i,j;
        int w1,r,rw1;
        FILE *fpin;
        FILE *fpout;
        progname = argv[0];

        if ( argc != 3 ) { /* Wheel name appended */
                usage();
        }

        fpin = fopen(argv[1], "r");
        if(fpin == NULL) {
                err("Can't open file for reading",errno);
                fprintf(stderr,"failed to open file %s\n",argv[1]);
                exit(1);
        }
        fpout = fopen(argv[2], "w");
        if(fpout== NULL) {
                err("Can't open file for writing",errno);
                fprintf(stderr,"failed to open file %s\n",argv[1]);
                exit(1);
        }


        while ((c = fgetc(fpin)) != EOF) {
                /* Trough rotors */
                for (i=0; i < 3; i++) {
                        c = rotor(order[i],position[i],c);
                }
                /* Reflector */
                c = reflector(c);
                /* Trough reverse rotors */
                for (i=0; i < 3; i++) {
                        c = revrotor(order[2-i],position[2-i],c);
                }
                fputc(c,fpout);
                tick();
                /*printf("position: %3i %3i %3i\n",position[0],position[1],position[2]);*/
        }
        if ( fclose(fpin) != 0 ) {
                fprintf(stderr,"Cannot close input file\n");
                exit(5);
        }
        if ( fclose(fpout) != 0 ) {
                fprintf(stderr,"Cannot close output file\n");
                exit(5);
        }
        exit(0); /* Succes */
}
</source>
</div>
[[Category:C]][[Category:CoE]]