products/sources/formale sprachen/C image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: options.c   Sprache: C

//******************************************************************************
//
//            Options handling
//
//       .....
//
//******************************************************************************
//------------------------------------------------------------------------------
//   library includes
//------------------------------------------------------------------------------
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
//------------------------------------------------------------------------------
//   columbo includes
//------------------------------------------------------------------------------
#include "proto.h" 
#include "error.h" 
#include "options.h"
//------------------------------------------------------------------
//   machine specific intel architecture:
//------------------------------------------------------------------
#define TRACE 0
#undef LITTLE_ENDIAN
//------------------------------------------------------------------
//   constant
//------------------------------------------------------------------
#define maxoptsize 512000
//------------------------------------------------------------------
//   security
//------------------------------------------------------------------
#define secure(a,b) if (!(b==a%63)) {yyexit(8057);}
//#define DEBUG
//------------------------------------------------------------------
//   wide char conversion
//------------------------------------------------------------------
#define psmallchar(aa,bb) \
 char * optionsfilename=malloc(1000); \
 int p=0,q=0;char d=aa[p];   \
 while (aa[p]) {             \
   bb[q]=aa[p]; \
   q++;p+=2;}                   \
   bb[q]=0;
//------------------------------------------------------------------
//   getoptions
//------------------------------------------------------------------
__declspec(dllexport) int getoptions(long optsize,char* optin,char* opt, long callkey) {
 long optkeylen=8;unsigned char* soptions;long iosize;FILE *fi;
 unsigned char sin[maxoptsize], sout[maxoptsize];long i;
 unsigned char cc;unsigned char key[9], *buf=(char*)malloc(9);
 unsigned char * ast(unsigned char * s);
 // convert to bytestring
 psmallchar(optin,optionsfilename)
 //get filename for key
 for (i=strlen(optionsfilename)-1;(i>0) && (optionsfilename[i]!='\\') && (optionsfilename[i]!='/');i--);
 soptions=optionsfilename+i+1;
 // right caller?
 secure(optsize,callkey)  
 // take care
 if (optsize>maxoptsize) yyexit(8058); 
 // construct Key DES3
 #if defined(DELPHI) | defined(MINGW)  | defined(LINUX)
 for(i=0;i<=3;i++)  key[2*i]   = soptions[3+i];
 for (i=0;i<=3;i++) key[2*i+1] = soptions[9-i];
 #else
 key[0]=soptions[7]-1;
 key[1]=soptions[5];
 key[2]=soptions[0]-2;
 for(i=0;i<=1;i++)  key[3+i]   = soptions[4-2*i];
 key[5]=soptions[3];
 for(i=0;i<=1;i++)  key[6+i]   = soptions[6];
 for(i=0;i<=1;i++)  key[6+i]  += 64;
 for(i=0;i<8;i++)   buf[i]=key[i];buf[8]=0;
 buf=as(buf);
 for(i=0;i<8;i++)   key[i]=buf[i];
 #endif
 //
 if ((fi=fopen(optionsfilename,"rb"))!=NULL) {
   iosize=0;
   while (fscanf(fi,"%c",&cc) && (iosize<optsize)) {
     sin[iosize]=cc;
     iosize+=1;}
   fclose(fi);
   // Check for licence in Opt.R.dat
   if (abs(iosize - optsize) > 0) {
     //oerror("8036! Optionen korrupt");
     yyexit(8059);}
   if (optsize>maxoptsize) {
     //oerror("8037! Optionen korrupt");
     yyexit(8060);}
   // ------- decrypt ---------
   decrypt(sin,sout,key,optsize,optkeylen);
   for (i=0;i<optsize;i++) opt[i]=sout[i];
   // right caller?
   secure(optsize,callkey)
   // ------- fin -------------
   if (optsize-iosize>0) {
     //oerror("8038! falsche Gre");
     }}
  else
    yyexit(8061);
  #if TRACE
    if (opt) {
      JString win=opt+27;
      printf("win=%s\n",win);}
  #endif
return 0;}
//-----------------------------------------------------------------
//   putoptions
//-----------------------------------------------------------------
__declspec(dllexport) int putoptions(long optsize,char* optin,char* opt, long callkey) {
//int cputoptions(long optsize,unsigned char* optionsfilename,unsigned char* opt) {
 long optkeylen=8;static unsigned char* soptions;long iosize;FILE *fi;
 unsigned char sin[maxoptsize], sout[maxoptsize];long i;static unsigned char key[9];
 psmallchar(optin,optionsfilename)
 // get filename for key
 for (i=strlen(optionsfilename)-1;(i>0) && (optionsfilename[i]!='\\')&& (optionsfilename[i]!='/');i--);
 soptions=optionsfilename+i+1;
 // right caller?
 secure(optsize,callkey)
 // take care
 if (optsize>maxoptsize) yyexit(8062);
 // construct Key DES3
 for(i=0;i<=3;i++)  key[2*i]   = soptions[3+i];
 for (i=0;i<=3;i++) key[2*i+1] = soptions[9-i];
 //
 // ------ encrypt --------
 for (i=0;i<optsize;i++) sin[i] =opt[i];
 //for (i=0;i<optsize;i++) sout[i]=sin[i];
 encrypt(sin,sout,key,optsize,optkeylen);
 // ------- fin -------------
 if ((fi=fopen(optionsfilename,"wb"))!=NULL) {
   iosize=0;
   while (iosize<optsize) {
     fprintf(fi,"%c",sout[iosize]);
     iosize+=1;}
   fclose(fi);
   // right caller?
   secure(optsize,callkey)
   if (optsize-iosize>0) {
     //oerror("8038! falsche Gre");
     }}
 else
   yyexit(8063);
return 0;}
//------------------------------------------------------------------
//   getoptions
//------------------------------------------------------------------
__declspec(dllexport) int patchoptions(long optsize,char* optionsfilename,char* opt, long callkey,
                                       char *ipaddr,char *winprodid,char *diskid,char *edit) {
 long i;
 const long Windowsproductid=26;   // string[24]
 const long IPAddr=101;            // string[24]
 const long DiskId=76;             // string[24]
 const long Edition=3129;          // byte?
 //const long Activated=3128+1;    // boolean
 //const long EthernetAddr=126+1;  // string[24]
 //const long CPU=51+1;            // string[24]
 getoptions(optsize,optionsfilename,opt,callkey);
 if (winprodid) {
   int ll=strlen(winprodid);
   opt[Windowsproductid]=ll;
   if (ll>24) yyexit(8064);
   for (i=1;i<=ll;i++) 
   opt[Windowsproductid+i]=winprodid[i-1];}
 if (ipaddr) {
   int ll=strlen(ipaddr);
   opt[IPAddr]=ll;
   opt[IPAddr+ll]=0;
   if (ll>24) yyexit(8065);
   for (i=1;i<=ll;i++) 
     opt[IPAddr+i]=ipaddr[i-1];}
 if (diskid) {
   int ll=strlen(diskid);
   opt[DiskId]=ll;
   opt[DiskId+ll]=0;
   if (ll>24) yyexit(8066);
   for (i=1;i<=ll;i++) 
   opt[DiskId+i]=diskid[i-1];}
 if (edit) {
   int ll=strlen(edit);
   if (ll>24) yyexit(8067);
   for (i=0;i<4;i++) 
   opt[Edition+i]=edit[i];}
 putoptions(optsize,optionsfilename,opt,callkey);
return 0;}
//-----------------------------------------------------------------------------
//       make transparent char an ascii
//-----------------------------------------------------------------------------
unsigned char t2a(unsigned char c) {
 unsigned char e;
 if       (c==' ')              e=0;
 else if ((c>='a') && (c<='z')) e=c-'a'+1; 
 else if ((c>='A') && (c<='Z')) e=c-'A'+26+1; 
 else if ((c>='0') && (c<='9')) e=c-'0'+26+26+1;
 else if  (c=='-')              e=10+26+26+1;
 else                           exit(100);
return e;}
//-----------------------------------------------------------------------------
//       make transparent char an ascii
//-----------------------------------------------------------------------------
unsigned char a2t(unsigned char c) {
 unsigned char e;
 if (c==0)                    e=' ';
 else if ((c>=1)  && (c<=26)) e=c+'a'-1; 
 else if ((c>=27) && (c<=52)) e=c-26+'A'-1; 
 else if ((c>=53) && (c<=62)) e=c-52+'0'-1;
 else if (c==63)              e='-';
 else                         exit(100);
return e;}
//-----------------------------------------------------------------------------
//       make a string transparent
//-----------------------------------------------------------------------------
unsigned char *b642a(unsigned char* win, unsigned int ll) {
 unsigned int i,j,k;int b[4];unsigned int ol=3*(ll/4+1);
 unsigned long z;unsigned char *er=malloc(8*(ol/8+1));
 if (ll>65) exit(100);
 k=0;j=0;b[0]=b[1]=b[2]=b[3]=0;
 for (i=0;i<strlen(win);i++) {
   b[k]=t2a(win[i]);
   k++;
   if (k==4) {z=b[3]+64*b[2]+64*64*b[1]+64*64*64*b[0];
              er[j]=z/(256*256);z=z-256*256*er[j];j++;
              er[j]=z/256;z=z-256*er[j];j++;
              er[j]=z;j++;
              k=0;b[0]=b[1]=b[2]=b[3]=0;}}
 if (k>0)  {z=b[3]+64*b[2]+64*64*b[1]+64*64*64*b[0];
            er[j]=z/(256*256);z=z-256*256*er[j];j++;
            er[j]=z/256;z=z-256*er[j];j++;
            er[j]=z;j++;}
 //if (j!=ol) exit(100);
return er;}
//-----------------------------------------------------------------------------
//       make a string transparent
//-----------------------------------------------------------------------------
unsigned char *a2b64(unsigned char* win, unsigned int ll) {
 unsigned int i,j=0;int k=0,t=0;int b[4];unsigned int ol=4*ll/3;
 unsigned char *er=malloc(8*(ol/8+1));
 unsigned long z=0;b[0]=b[1]=b[2]=b[3]=0;
 if (3*ll/4+1>64) exit(100);
 for (i=0;(i<ol) && (win[i]!=0);i++) {
   if      (t==0) {z=win[i];t++;}
   else if (t==1) {z=z*256+win[i];t++;}
   else if (t==2) {z=z*256+win[i];t++;}
   if (t>2) {
     b[3]=z%64;z=z/64;
     b[2]=z%64;z=z/64;
     b[1]=z%64;z=z/64;
     b[0]=z;t=0;z=0;
     for (k=0;k<4;k++) {
       er[j]=a2t(b[k]);
       j++;}}}
 if (t>0) {
   if      (t==1) z=z*256*256;
   else if (t==2) z=z*256;
   b[3]=z%64;z=z/64;
   b[2]=z%64;z=z/64;
   b[1]=z%64;z=z/64;
   b[0]=z;t=0;z=0;
   for (k=0;k<4;k++) {
     er[j]=a2t(b[k]);
     j++;}}
 //for (i=j;i>0;i--) if (er[i]==' ') er[i+1]=0;
 er[j]=0;
 //if (j!=ol+4) exit(100);  
return er;}
//-----------------------------------------------------------------------------
//       encrypt
//-----------------------------------------------------------------------------
__declspec(dllexport) int activate(char** sin,char** sout,char* key) {
  #define codelength 64
  unsigned int llt=strlen(*sin)>0?strlen(*sin):strlen(*sout),llk=strlen(key),lla,lld;
  unsigned int i,j,k,inp=(strlen(*sin)>0);int ol=8*(llt/8+1);
  unsigned char *work, *work1, *erg=malloc(8*(llt/8+1)), *win=malloc(8*(llt/8+1));
  if (llt>codelength) exit(100);
  if (inp) strcpy(win,*sin); else strcpy(win,*sout);
  // Length must be 32:24 or multiple
  llt=strlen(win);
  if (llt!=codelength) exit(100);
  work=b642a(win,llt);
  lla=3*llt/4;
  //lla=24;
  //work1=a2b64(work,lla);
  lld=8*((lla+7)/8);
  for (i=lla+1;i<=lld;i++) work[i]=0;  // fill up
  if      (inp)  {encrypt(work,erg,key,lld,llk);}
  else           {decrypt(work,erg,key,lld,llk);}
  //if      (inp)  {decrypt(erg,work,key,lld,llk);erg=work;win=a2trans(work,lld);}
  //else           {encrypt(erg,work,key,lld,llk);erg=work;win=a2trans(work,lld);}
  if (inp) win=*sout=a2b64(erg,lld); else win=*sin=a2b64(erg,lld); 
  win[llt]=0;   // now shorten to original length
return 0;}
//-----------------------------------------------------------------------------
//       encrypt
//-----------------------------------------------------------------------------
int encrypt(char* sin,char* sout,char* key,long datalen,long keylen) {
 long i,c,b=8,k,ll=datalen / b+1;
 char deskey[8];char work[8];
 for (i=0;i<8;i++) deskey[i]=i+1;
 if (datalen % b!=0) return -711;
 if (keylen !=8)     return -711;
 desinit(0);
 for (k=0;k<3;k++) {        // 3DES
   for (i=0;i<8;i++) {
     int m=(i+1023)%8;
     int t=deskey[m];
     deskey[m]=deskey[i];
     deskey[i]=t;}
   if (k==0) setkey(key);
   else      setkey(deskey);
   for (i=0;i<ll;i++) {
     int u=b;if (i*b+b>datalen) u=datalen-i*b;
     for (c=0;c<u;c++) work[c]=sin[i*b+c];
     if (u<b) for (c=u;c<b;c++) work[c]=0;
     endes(work);
     for (c=0;c<u;c++) sout[i*b+c]=work[c];}}
 return 0;}
//-----------------------------------------------------------------------------
//       encrypt
//-----------------------------------------------------------------------------
int decrypt(char* sin,char* sout,char* key,long datalen,long keylen) {
 long i,c,b=8,k,ll=datalen / b+1;
 char deskey[8];char work[8];
 for (i=0;i<8;i++) deskey[i]=i+1;
 if (datalen % b!=0) return -711;
 if (keylen !=8)     return -711;
 desinit(0);
 for (k=0;k<3;k++) {       // 3DES
   for (i=0;i<8;i++) {
     int m=(i+1023)%8;
     int t=deskey[m];
     deskey[m]=deskey[i];
     deskey[i]=t;}
   if (k==0) setkey(key);
   else      setkey(deskey);
   for (i=0;i<ll;i++) {
     int u=b;if (i*b+b>datalen) u=datalen-i*b;
     for (c=0;c<u;c++) work[c]=sin[i*b+c];
     #if TRACE
  printf("%i:dedes=%02x%02x%02x%02x%02x%02x%02x%02x\n",i,work[0],work[1],work[2],work[3],work[4],work[5],work[6],work[7]);
  #endif
  dedes(work);
     for (c=0;c<u;c++) sout[i*b+c]=work[c];}}
 return 0;}
//-----------------------------------------------------------------------------
// Sofware DES functions
// written 12 Dec 1986 by Phil Karn, KA9Q; large sections adapted from
// the 1977 public-domain program by Jim Gillogly
//-----------------------------------------------------------------------------

#if defined(LITTLE_ENDIAN)
long byteswap();
#endif

/* Tables defined in the Data Encryption Standard documents */

/* initial permutation IP */
static char ip[] = {
        58, 50, 42, 34, 26, 18, 10,  2,
        60, 52, 44, 36, 28, 20, 12,  4,
        62, 54, 46, 38, 30, 22, 14,  6,
        64, 56, 48, 40, 32, 24, 16,  8,
        57, 49, 41, 33, 25, 17,  9,  1,
        59, 51, 43, 35, 27, 19, 11,  3,
        61, 53, 45, 37, 29, 21, 13,  5,
        63, 55, 47, 39, 31, 23, 15,  7
};

/* final permutation IP^-1 */
static char fp[] = {
        40,  8, 48, 16, 56, 24, 64, 32,
        39,  7, 47, 15, 55, 23, 63, 31,
        38,  6, 46, 14, 54, 22, 62, 30,
        37,  5, 45, 13, 53, 21, 61, 29,
        36,  4, 44, 12, 52, 20, 60, 28,
        35,  3, 43, 11, 51, 19, 59, 27,
        34,  2, 42, 10, 50, 18, 58, 26,
        33,  1, 41,  9, 49, 17, 57, 25
};

/* expansion operation matrix
 * This is for reference only; it is unused in the code
 * as the f() function performs it implicitly for speed
 */

#ifdef notdef
static char ei[] = {
        32,  1,  2,  3,  4,  5,
         4,  5,  6,  7,  8,  9,
         8,  9, 10, 11, 12, 13,
        12, 13, 14, 15, 16, 17,
        16, 17, 18, 19, 20, 21,
        20, 21, 22, 23, 24, 25,
        24, 25, 26, 27, 28, 29,
        28, 29, 30, 31, 32,  1 
};
#endif

/* permuted choice table (key) */
static char pc1[] = {
        57, 49, 41, 33, 25, 17,  9,
         1, 58, 50, 42, 34, 26, 18,
        10,  2, 59, 51, 43, 35, 27,
        19, 11,  3, 60, 52, 44, 36,

        63, 55, 47, 39, 31, 23, 15,
         7, 62, 54, 46, 38, 30, 22,
        14,  6, 61, 53, 45, 37, 29,
        21, 13,  5, 28, 20, 12,  4
};

/* number left rotations of pc1 */
static char totrot[] = {
        1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
};

/* permuted choice key (table) */
static char pc2[] = {
        14, 17, 11, 24,  1,  5,
         3, 28, 15,  6, 21, 10,
        23, 19, 12,  4, 26,  8,
        16,  7, 27, 20, 13,  2,
        41, 52, 31, 37, 47, 55,
        30, 40, 51, 45, 33, 48,
        44, 49, 39, 56, 34, 53,
        46, 42, 50, 36, 29, 32
};

/* The (in)famous S-boxes */
static char si[8][64] = {
        /* S1 */
        {14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
         0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
         4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
        15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13},

        /* S2 */
        {15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
         3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
         0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
        13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9},

        /* S3 */
        {10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
        13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
        13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
         1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12},

        /* S4 */
        { 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
        13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
        10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
         3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14},

        /* S5 */
        { 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
        14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
         4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
        11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3},

        /* S6 */
        {12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
        10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
         9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
         4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13},

        /* S7 */
        { 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
        13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
         1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
         6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12},

        /* S8 */
        {13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
         1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
         7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
         2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11}
};

/* 32-bit permutation function P used on the output of the S-boxes */
static char p32i[] = {        
        16,  7, 20, 21,
        29, 12, 28, 17,
         1, 15, 23, 26,
         5, 18, 31, 10,
         2,  8, 24, 14,
        32, 27,  3,  9,
        19, 13, 30,  6,
        22, 11,  4, 25
};
/* End of DES-defined tables */

/* Lookup tables initialized once only at startup by desinit() */
static long (*sp_)[64];                /* Combined S and P boxes */

static char (*iperm)[16][8];        /* Initial and final permutations */
static char (*fperm)[16][8];

/* 8 6-bit subkeys for each of 16 rounds, initialized by setkey() */
static char (*kn)[8];

/* bit 0 is left-most in byte */
static int bytebit[] = {
        0200,0100,040,020,010,04,02,01
};

static int nibblebit[] = {
         010,04,02,01
};
static int desmode;

/* Allocate space and initialize DES lookup arrays
 * mode == 0: standard Data Encryption Algorithm
 * mode == 1: DEA without initial and final permutations for speed
 * mode == 2: DEA without permutations and with 128-byte key (completely
 *            independent subkeys for each round)
 */

int desinit(int mode) {
        //char *malloc();                         // Co3

        if(sp_ != NULL){
                /* Already initialized */
                return 0;
        }
        desmode = mode;
        
        if((sp_ = (long (*)[64])malloc(sizeof(long) * 8 * 64)) == NULL){
                return -1;
        }
        spinit();
        kn = (char (*)[8])malloc(sizeof(char) * 8 * 16);
        if(kn == NULL){
                free((char *)sp_);
                return -1;
        }
        if(mode == 1 || mode == 2)        /* No permutations */
                return 0;

        iperm = (char (*)[16][8])malloc(sizeof(char) * 16 * 16 * 8);
        if(iperm == NULL){
                free((char *)sp_);
                free((char *)kn);
                return -1;
        }
        perminit(iperm,ip);

        fperm = (char (*)[16][8])malloc(sizeof(char) * 16 * 16 * 8);
        if(fperm == NULL){
                free((char *)sp_);
                free((char *)kn);
                free((char *)iperm);
                return -1;
        }
        perminit(fperm,fp);
        
        return 0;
}
/* Free up storage used by DES */
void desdone(void) {
        if(sp_ == NULL)
                return;        /* Already done */

        free((char *)sp_);
        free((char *)kn);
        if(iperm != NULL)
                free((char *)iperm);
        if(fperm != NULL)
                free((char *)fperm);

        sp_ = NULL;
        iperm = NULL;
        fperm = NULL;
        kn = NULL;
}
/* Set key (initialize key schedule array) */
void setkey(char *key) {             /* 64 bits (will use only 56) */
        char pc1m[56];                /* place to modify pc1 into */
        char pcr[56];                /* place to rotate pc1 into */
        int i,j,l;
        int m;

        /* In mode 2, the 128 bytes of subkey are set directly from the
         * user's key, allowing him to use completely independent
         * subkeys for each round. Note that the user MUST specify a
         * full 128 bytes.
         *
         * I would like to think that this technique gives the NSA a real
         * headache, but I'm not THAT naive.
         */

        if(desmode == 2){
                for(i=0;i<16;i++)
                        for(j=0;j<8;j++)
                                kn[i][j] = *key++;
                return;
        }
        /* Clear key schedule */
        for (i=0; i<16; i++)
                for (j=0; j<8; j++)
                        kn[i][j]=0;

        for (j=0; j<56; j++) {                /* convert pc1 to bits of key */
                l=pc1[j]-1;                /* integer bit location         */
                m = l & 07;                /* find bit                 */
                pc1m[j]=(key[l>>3] &        /* find which key byte l is in */
                        bytebit[m])        /* and which bit of that byte */
                        ? 1 : 0;        /* and store 1-bit result */
        }
        for (i=0; i<16; i++) {                /* key chunk for each iteration */
                for (j=0; j<56; j++)        /* rotate pc1 the right amount */
                        pcr[j] = pc1m[(l=j+totrot[i])<(j<28? 28 : 56) ? l: l-28];
                        /* rotate left and right halves independently */
                for (j=0; j<48; j++){        /* select bits individually */
                        /* check bit that goes to kn[j] */
                        if (pcr[pc2[j]-1]){
                                /* mask it in if it's there */
                                l= j % 6;
                                kn[i][j/6] |= bytebit[l] >> 2;
                        }
                }
        }
}
/* In-place encryption of 64-bit block */
void endes(char *block) {
        int i;
        unsigned long work[2];                 /* Working data storage */
        unsigned long tmp;

        permute(block,iperm,(char *)work);        /* Initial Permutation */
#if defined(LITTLE_ENDIAN) 
        work[0] = byteswap(work[0]);
        work[1] = byteswap(work[1]);
#endif

        /* Do the 16 rounds */
        for (i=0; i<16; i++)
                desround(i,work);

        /* Left/right half swap */
        tmp = work[0];
        work[0] = work[1];        
        work[1] = tmp;

#if defined(LITTLE_ENDIAN) 
        work[0] = byteswap(work[0]);
        work[1] = byteswap(work[1]);
#endif
        permute((char *)work,fperm,block);        /* Inverse initial permutation */
}
/* In-place decryption of 64-bit block */
void dedes(char *block) {
        int i;
        unsigned long work[2];        /* Working data storage */
        unsigned long tmp;

        permute(block,iperm,(char *)work);        /* Initial permutation */

#if defined(LITTLE_ENDIAN)
        work[0] = byteswap(work[0]);
        work[1] = byteswap(work[1]);
#endif

        /* Left/right half swap */
        tmp = work[0];
        work[0] = work[1];        
        work[1] = tmp;

        #if TRACE
      printf("dedes 1=%x %x\n",work[0],work[1]);
     #endif

    /* Do the 16 rounds in reverse order */
        for (i=15; i >= 0; i--)
                desround(i,work);

#if defined(LITTLE_ENDIAN)
        work[0] = byteswap(work[0]);
        work[1] = byteswap(work[1]);
#endif
        #if TRACE
      printf("desround=%x %x\n",work[0],work[1]);
     #endif

        permute((char *)work,fperm,block);        /* Inverse initial permutation */
        #if TRACE
      printf("dedes 2=%x %x\n",work[0],work[1]);
     #endif
}

/* Permute inblock with perm */
static void permute(char *inblock,char perm[16][16][8],char *outblock) {
                         /* result into outblock,64 bits */
                         /* 2K bytes defining perm. */
        int i,j;
        char *ib, *ob;                /* ptr to input or output block */
        char *p, *q;

        #if TRACE
       printf("inblock=%02x%02x%02x%02x%02x%02x%02x%02x\n",
   inblock[0],inblock[1],inblock[2],inblock[3],inblock[4],inblock[5],inblock[6],inblock[7]);
     #endif

  if(perm == NULL){
                /* No permutation, just copy */
                for(i=8; i!=0; i--)
                        *outblock++ = *inblock++;
                return;
        }
        /* Clear output block         */
        for (i=8, ob = outblock; i != 0; i--)
                *ob++ = 0;

        ib = inblock;
        for (j = 0; j < 16; j += 2, ib++) { /* for each input nibble */
          int ix=(*ib >> 4) & 017;
          int iy=*ib & 017;
    ob = outblock;
          p = perm[j][ix];
          q = perm[j + 1][iy];
          #if TRACE
      printf("(ix,iy)=(%i,%i) (p,q)=(%02x%02x%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x%02x%02x)\n",
                    ix,iy,p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7]);
    #endif
          for (i = 8; i != 0; i--){           /* and each output byte */
            *ob++ |= *p++ | *q++;        /* OR the masks together*/
          }
        }
        #if TRACE
       printf("outblock=%02x%02x%02x%02x%02x%02x%02x%02x\n",
   outblock[0],outblock[1],outblock[2],outblock[3],outblock[4],outblock[5],outblock[6],outblock[7]);
     #endif
}

/* Do one DES cipher round */
static void desround(int num,unsigned long *block) {   /* i.e. the num-th one         */
        //long f();

        /* The rounds are numbered from 0 to 15. On even rounds
         * the right half is fed to f() and the result exclusive-ORs
         * the left half; on odd rounds the reverse is done.
         */

        if(num & 1){
                block[1] ^= f(block[0],kn[num]);
        } else {
                block[0] ^= f(block[1],kn[num]);
        }
}
/* The nonlinear function f(r,k), the heart of DES */
static long f(unsigned long r,char subkey[8]) {   /* 32 bits */
                                                          /* 48-bit key for this round */

        long rval,rt;
#if TRACE
        char *cp;
        int i;

        printf("f(%08lx, %02x %02x %02x %02x %02x %02x %02x %02x) = ",
                r,
                subkey[0], subkey[1], subkey[2],
                subkey[3], subkey[4], subkey[5],
                subkey[6], subkey[7]);
#endif
        /* Run E(R) ^ K through the combined S & P boxes
         * This code takes advantage of a convenient regularity in
         * E, namely that each group of 6 bits in E(R) feeding
         * a single S-box is a contiguous segment of R.
         */

        rt = (r >> 1) | ((r & 1) ? 0x80000000 : 0);
        rval = 0;
        rval |= sp_[0][((rt >> 26) ^ *subkey++) & 0x3f];
        rval |= sp_[1][((rt >> 22) ^ *subkey++) & 0x3f];
        rval |= sp_[2][((rt >> 18) ^ *subkey++) & 0x3f];
        rval |= sp_[3][((rt >> 14) ^ *subkey++) & 0x3f];
        rval |= sp_[4][((rt >> 10) ^ *subkey++) & 0x3f];
        rval |= sp_[5][((rt >> 6) ^ *subkey++) & 0x3f];
        rval |= sp_[6][((rt >> 2) ^ *subkey++) & 0x3f];
        rt = (r << 1) | ((r & 0x80000000) ? 1 : 0);
        rval |= sp_[7][(rt ^ *subkey) & 0x3f];
#if TRACE
        printf(" %08lx\n",rval);
#endif
        return rval;
}
/* initialize a perm array */
static void perminit(char perm[16][16][8],char p[64]) {  /* 64-bit, either init or final */
        int l, j, k;
        int i,m;

        /* Clear the permutation array */
        for (i=0; i<16; i++)
                for (j=0; j<16; j++)
                        for (k=0; k<8; k++) 
                                perm[i][j][k]=0;

        for (i=0;i<16;i++) {      /* each input nibble position */
          for (j = 0;j<16;j++)  { /* each possible input nibble */
            for (k = 0; k < 64; k++)/* each output bit position */
                {   l = p[k] - 1;        /* where does this bit come from*/
                        if ((l >> 2) != i)  /* does it come from input posn?*/
                        continue;        /* if not, bit k is 0         */
                        if (!(j & nibblebit[l & 3]))
                        continue;        /* any such bit in input? */
                        m = k & 07;        /* which bit is this in the byte*/
                        perm[i][j][k>>3] |= bytebit[m];
                     #if TRACE
                       printf("perminit l=%i perm[%i][%i][%i]=%i\n",l,i,j,k>>3,perm[i][j][k>>3]);
                     #endif
                }}}
}

/* Initialize the lookup table for the combined S and P boxes */
static void spinit() {
        char pbox[32];
        int p,i,s,j,rowcol;
        long val;

        /* Compute pbox, the inverse of p32i.
         * This is easier to work with
         */

        for(p=0;p<32;p++){
                for(i=0;i<32;i++){
                        if(p32i[i]-1 == p){
                                pbox[p] = i;
                                break;
                        }
                }
        }
        for(s = 0; s < 8; s++){                        /* For each S-box */
                for(i=0; i<64; i++){                /* For each possible input */
                        val = 0;
                        /* The row number is formed from the first and last
                         * bits; the column number is from the middle 4
                         */

                        rowcol = (i & 32) | ((i & 1) ? 16 : 0) | ((i >> 1) & 0xf);
                        for(j=0;j<4;j++){        /* For each output bit */
                                if(si[s][rowcol] & (8 >> j)){
                                 val |= 1L << (31 - pbox[4*s + j]);
                                }
                        }
                        sp_[s][i] = val;

#ifdef        DEBUG
                        printf("sp_[%d][%2d] = %08lx\n",s,i,sp_[s][i]);
#endif
                }
        }
}
#if defined(LITTLE_ENDIAN)
/* Byte swap a long */
static  unsigned long byteswap(unsigned long x) {
        char *cp,tmp;

        cp = (char *)&x;
        tmp = cp[3];
        cp[3] = cp[0];
        cp[0] = tmp;

        tmp = cp[2];
        cp[2] = cp[1];
        cp[1] = tmp;

        return x;
}
#endif
//------------------------------------------------------------------------------
//               E n d e   d i e s e r   Q u e l l e
//------------------------------------------------------------------------------




¤ Dauer der Verarbeitung: 0.110 Sekunden  (vorverarbeitet)  ¤





Download des
Quellennavigators
Download des
sprechenden Kalenders

in der Quellcodebibliothek suchen




Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.


Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff