#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <fcntl.h>

#define MAXBIGRAMS 20
#define BUFSIZE 4096

typedef struct letter
 {
  unsigned char val;
  int count;
 } LETTER;

typedef struct funct
 {
  char *name;
  void (*handler)();
  char *fullname;
 } FUNC;

typedef unsigned char(*CRYPTOF)(unsigned char, unsigned char);


/* Common data */
unsigned char buffer[BUFSIZE];
int fd;
char *filename;
float threshold=1.50,maxallowederr=0.50;

char *functioname;
int myargc;
char **myargv;

/* Used by stat+decrypt */
LETTER letters[256]; int totall;

/* Used by decrypt */
char allowedchars[256];
int alloweds;
char allowed[256];
int bads[256];


void decrypt();
void stat();
unsigned char add(unsigned char, unsigned char);
unsigned char sub(unsigned char, unsigned char);
unsigned char xor(unsigned char, unsigned char);

FUNC functions[]=
 {
  {"decrypt",decrypt,"[Decrypt]"},
  {"stat",stat,"[Statistics]"},
  {0,NULL}
 };

void out(char *fmt, ...)
 {
  va_list ap;
  va_start(ap, fmt);
  if (functioname) printf("%s ",functioname);
  vprintf(fmt,ap);
  va_end(ap);
 }
             
void fatal(char *fmt, ...)
 {
  va_list ap;
  va_start(ap, fmt);
  if (functioname) printf("%s:[FATAL]\n  ",functioname);
  vprintf(fmt,ap);
  va_end(ap);
  printf("\n");
  _exit(-1);
 }
             

void usage()
 {
  printf("Commands:\n");
  printf("  decrypt     Decrypt\n");
  printf("    -a<file>  Read allowed characters from file\n");
  printf("    -t<value> Threshold for decrypting (in %%)\n");
  printf("    -m<value> Maximal allowed error (in %%)\n");
  printf("\n");
  printf("  stat        Create statistics\n");
  printf("    -o<file>  Generate allowed characters file\n");
  exit(-1);
 }

void AddStatistics(unsigned char *data, int len)
 {
  int i;
  
  for (i=0;i<len;i++) letters[data[i]].count++;
  totall+=len;
 }

int compar(const void *aa, const void *bb)
 {
  int a=((LETTER*)aa)->count,b=((LETTER*)bb)->count;
  if (a<b) return 1; else if (a==b) return 0; else return -1;
 }

void genstat()
 {
  int readed;
  unsigned char c;
  
  memset(letters,0,sizeof(letters)); totall=0;
  for (c=1;c;c++) letters[c].val=c;
  out("Reading + generation of statistics");
  lseek(fd,0,SEEK_SET);
  while(readed=read(fd,buffer,BUFSIZE))
   {
    if (readed<0) { putchar('\n'); fatal("Error while reading"); }
    AddStatistics(buffer,readed);
    putchar('.');
   }
  putchar('\n');
  qsort(letters,256,sizeof(LETTER),compar);
 }

void ReadAllowedChars(char *fname)
 {
  int fdd;
  unsigned char c;
  
  if (!fname || !*fname) fname="chars.in";
  out("Reading AllowedChars\n");
  memset(allowedchars,0,sizeof(allowedchars));
  memset(allowed,0,sizeof(allowed));
  alloweds=0;
  if ((fdd=open(fname,O_RDONLY))<0)
   {
    out("Unable to open allowedChars(%s) for reading\n",fname);
    return;
   }
  while(read(fdd,&c,1)>0)
   {
    if (!allowed[c]) allowedchars[alloweds++]=c;
    allowed[c]=1;
   }
  close(fdd);
 }

void WriteAllowedChars(char *fname)
 {
  int fdd;
  int i;
  
  if (!fname || !*fname) fname="chars.out";
  out("Writing AllowedChars\n");
  if ((fdd=open(fname,O_WRONLY|O_CREAT,0644))<0)
   {
    out("Unable to open allowedChars(%s) for writing\n",fname);
    return;
   }
  for (i=0;(i<256) && letters[i].count;i++) write(fdd,&letters[i].val,1);
  close(fdd);
 }

unsigned char add(unsigned char a, unsigned char b) { return a+b; }
unsigned char sub(unsigned char a, unsigned char b) { return a-b; }
unsigned char xor(unsigned char a, unsigned char b) { return a^b; }

/* encr(x,key), decr(x,key), keyr(enc,dec) */

void TrySimpleCrypto(char *prefix, CRYPTOF encr, CRYPTOF decr, CRYPTOF keyr)
 {
  int i,c,j,minbad;
  unsigned char key,ccrr,llff;
  int crlfdelta;
  int fdd;
  int readed;
  char *fname;
  
  minbad=totall+1;
  for (i=0;i<alloweds;i++)
   {
    key=keyr(letters[0].val,allowedchars[i]);
    ccrr=encr('\r',key); llff=encr('\n',key);
    crlfdelta=0;
    
    for (bads[i]=0,c=0;c<256;c++)
     {
      if (!letters[c].count) continue;
      if (letters[c].val==ccrr) crlfdelta+=letters[c].count;
      if (letters[c].val==llff) crlfdelta-=letters[c].count;
      if (!allowed[encr(letters[c].val,key)])
        bads[i]+=letters[c].count;
     }
    if (crlfdelta>0) bads[i]+=sqrt(crlfdelta);

    if (bads[i]<minbad) minbad=bads[i];
   }
  printf("  Minimal error found: %4.2f%%\n",100.0*minbad/totall);
  if (minbad<maxallowederr*totall)
  for (i=0;i<alloweds;i++) if (bads[i]<=threshold*(minbad+1))
   {
    key=keyr(letters[0].val,allowedchars[i]);
    if (!bads[i]) printf("  (FullShot)");
    printf("  Key: 0x%.2x, rerror=%4.2f%%,   writing...\n",key,minbad?
      100.0*bads[i]/minbad-100:-bads[i]);
    lseek(fd,0,SEEK_SET);
    fname=(char*)strdup(filename);
    fname=realloc(fname,strlen(fname)+strlen(prefix)+6);
    sprintf(fname,"%s-%s-%.2x",filename,prefix,key);
    free(fname);
    if ((fdd=open(fname,O_WRONLY|O_CREAT,0644))<0)
     { out("Unable to open (%s) for writing\n",fname); continue; }
    while(readed=read(fd,buffer,sizeof(buffer)))
     {
      for (j=0;j<readed;j++) buffer[j]=decr(buffer[j],key);
      write(fdd,buffer,readed);
     }
    close(fdd);
   }
 }


void decrypt()
 {
  int i;
  
  out("Activated\n");
  out("Opening %s\n",filename);
  if ((fd=open(filename,O_RDONLY))<0) fatal("Unable to open %s",filename);
  genstat();

  for (i=0;i<(alloweds=256);i++) { allowed[i]=1; allowedchars[i]=i; }
  for (i=3;i<myargc;i++)
   {
    if (myargv[i][0]!='-') { out("Unknown argument (%s), ignored\n",myargv[i]);}
    else switch(myargv[i][1])
      {
       case 'a': ReadAllowedChars(myargv[i]+2); break;
       case 't':
        threshold=1.0+strtod(myargv[i]+2,0)/100;
        if (threshold<1.0) threshold=1.0;
        break;
       case 'm':
        maxallowederr=strtod(myargv[i]+2,0)/100;
        if (maxallowederr<0) maxallowederr=0;
        break;
       default: out("Unknown option (%s), ignored\n",myargv[i]);
      }
   }
  
  out("Decrypting...\n");
  out("Using threshold=%d%%, maxerr=%d%%\n",(int)(100*threshold-100),(int)(100*maxallowederr));
  out("Trying ADD\n");
  TrySimpleCrypto("add",add,sub,sub);
  out("Trying XOR\n");
  TrySimpleCrypto("xor",xor,xor,xor);
  close(fd);
 }


void stat()
 {
  int i;

  out("Activated\n");
  out("Opening %s\n",filename);
  if ((fd=open(filename,O_RDONLY))<0) fatal("Unable to open %s",filename);

  genstat(); 

  out("Results follow\n");
  for (i=0;i<256;i++) if (letters[i].count>=totall/98)
    {
     printf("0x%.2x: %5.2f%%",letters[i].val,100.0*letters[i].count/totall);
     if (letters[i].val>=0x20 && letters[i].val<0x7f)
      printf(" (%c)",letters[i].val);
     putchar('\n');
    }

  for (i=3;i<myargc;i++)
   {
    if (myargv[i][0]!='-') { out("Unknown argument (%s), ignored\n",myargv[i]);}
    else switch(myargv[i][1])
      {
       case 'o': WriteAllowedChars(myargv[i]+2); break;
       default: out("Unknown option (%s), ignored\n",myargv[i]);
      }
   }

  close(fd);
 }

void main(int argc, char *argv[])
 {
  int i;
  
  myargc=argc; myargv=argv;
  setbuf(stdout,NULL);
  
  if (argc<3) usage();
  filename=argv[2];
  for (i=0;functions[i].name;i++) if (!strcmp(argv[1],functions[i].name))
   {
    functioname=functions[i].fullname;
    functions[i].handler();
    break;
   }
  if (!functions[i].name)
   {
    printf("What do you mean by '%s'?\n",argv[1]);
    exit(-1);
   }
 }