Difference between revisions of "Enigma/enigma8."

/**************************************************************************
  #     #
  ##   ##  ######  #####    ####     ##    #    #   #####  ######   ####
  # # # #  #       #    #  #    #   #  #   ##   #     #    #       #    #
  #  #  #  #####   #    #  #       #    #  # #  #     #    #####   #
  #     #  #       #####   #       ######  #  # #     #    #       #
  #     #  #       #   #   #    #  #    #  #   ##     #    #       #    #
  #     #  ######  #    #   ####   #    #  #    #     #    ######   ####

***************************************************************************
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:
  09. nov 2024 - Eome bugs removed
***************************************************************************
License:  Free open software but WITHOUT ANY WARRANTY.
Terms..:  see http://www.gnu.org/licenses
**************************************************************************/
#include <errno.h>
#include <stdlib.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 an 8-bit 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 */
}