home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / msdos / c / des / des.c next >
Encoding:
C/C++ Source or Header  |  1990-09-24  |  6.9 KB  |  291 lines
  1. /* ---------------------- des.c --------------------------- */
  2.  
  3. /*
  4.  * Functions and tables for DES encryption and decryption
  5.  */
  6.  
  7. /* ----- inline swapbyte function -------- */
  8.  
  9. #define swapbyte(c) {                                        \
  10.                            register int swt;                    \
  11.                            swt = *((char *)&c+3);                \
  12.                            *((char *)&c+3) = *(char *)&c;        \
  13.                            *(char *)&c = swt;                    \
  14.                            swt = *((char *)&c+2);                \
  15.                            *((char *)&c+2) = *((char *)&c+1);    \
  16.                            *((char *)&c+1) = swt;                \
  17.                      }
  18.  
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include "des.h"
  22.  
  23. /* -------- 48-bit key permutation ------- */
  24. struct ks    {
  25.     char ki[6];
  26. };
  27.  
  28. /* ------- two halves of a 64-bit data block ------- */
  29. struct LR    {
  30.     long L;
  31.     long R;
  32. };
  33.  
  34. static struct ks keys[16];
  35.  
  36. static void rotate(unsigned char *c, int n);
  37. static void inverse_permute(long *op,long *ip,long *tbl,int n);
  38. static void permute(long *op, long *ip, long *tbl, int n);
  39. static long f(long blk, struct LR *ky);
  40. static struct ks KS(int n, char *key);
  41.  
  42. /* ----------- initialize the key -------------- */
  43. void initkey(char *key)
  44. {
  45.     int i;
  46.     for (i = 0; i < 16; i++)
  47.         keys[i] = KS(i, key);
  48. }
  49.  
  50. /* ----------- encrypt an 8-byte block ------------ */
  51. void encrypt(char *blk)
  52. {
  53.    struct LR ip, op;
  54.    long temp;
  55.    int n;
  56.  
  57.    memcpy(&ip, blk, sizeof(struct LR));
  58.    /* -------- initial permuation -------- */
  59.    permute(&op.L, &ip.L, (long *)IPtbl, 64);
  60.    swapbyte(op.L);
  61.    swapbyte(op.R);
  62.    /* ------ swap and key iterations ----- */
  63.    for (n = 0; n < 16; n++)    {
  64.        temp = op.R;
  65.        op.R = op.L ^ f(op.R, (struct LR *) &keys[n]);
  66.        op.L = temp;
  67.    }
  68.    ip.R = op.L;
  69.    ip.L = op.R;
  70.    swapbyte(ip.L);
  71.    swapbyte(ip.R);
  72.    /* ----- inverse initial permutation ---- */
  73.    inverse_permute(&op.L, &ip.L,
  74.        (long *)IPtbl, 64);
  75.    memcpy(blk, &op, sizeof(struct LR));
  76. }
  77.  
  78. /* ----------- decrypt an 8-byte block ------------ */
  79. void decrypt(char *blk)
  80. {
  81.    struct LR ip, op;
  82.    long temp;
  83.    int n;
  84.  
  85.    memcpy(&ip, blk, sizeof(struct LR));
  86.    /* -------- initial permuation -------- */
  87.    permute(&op.L, &ip.L, (long *)IPtbl, 64);
  88.    swapbyte(op.L);
  89.    swapbyte(op.R);
  90.    ip.R = op.L;
  91.    ip.L = op.R;
  92.    /* ------ swap and key iterations ----- */
  93.    for (n = 15; n >= 0; --n)    {
  94.        temp = ip.L;
  95.        ip.L = ip.R ^ f(ip.L, (struct LR *) &keys[n]);
  96.        ip.R = temp;
  97.    }
  98.    swapbyte(ip.L);
  99.    swapbyte(ip.R);
  100.    /* ----- inverse initial permuation ---- */
  101.    inverse_permute(&op.L, &ip.L,
  102.        (long *)IPtbl, 64);
  103.    memcpy(blk, &op, sizeof(struct LR));
  104. }
  105.  
  106. /* ------- inverse permute a 64-bit string ------- */
  107. static void inverse_permute(long *op,long *ip,long *tbl,int n)
  108. {
  109.     int i;
  110.     long *pt = (long *)Pmask;
  111.  
  112.     *op = *(op+1) = 0;
  113.     for (i = 0; i < n; i++)    {
  114.        if ((*ip & *pt) || (*(ip+1) & *(pt+1)))  {
  115.            *op |= *tbl;
  116.            *(op+1) |= *(tbl+1);
  117.         }
  118.         tbl += 2;
  119.         pt += 2;
  120.    }
  121. }
  122.  
  123. /* ------- permute a 64-bit string ------- */
  124. static void permute(long *op, long *ip, long *tbl, int n)
  125. {
  126.     int i;
  127.     long *pt = (long *)Pmask;
  128.  
  129.     *op = *(op+1) = 0;
  130.     for (i = 0; i < n; i++)    {
  131.         if ((*ip & *tbl) || (*(ip+1) & *(tbl+1))) {
  132.             *op |= *pt;
  133.             *(op+1) |= *(pt+1);
  134.         }
  135.         tbl += 2;
  136.         pt += 2;
  137.     }
  138. }
  139.  
  140. /* ----- Key dependent computation function f(R,K) ----- */
  141. static long f(long blk, struct LR *key)
  142. {
  143.     static long or;
  144.     static int op;
  145.     static unsigned j, k;
  146.  
  147.     static union    {
  148.         struct LR f;
  149.         struct ks kn;
  150.     } tr;
  151.  
  152.      static union    {
  153.         long lg;
  154.         unsigned char ch[4];
  155.      } ir;
  156.  
  157.      tr.f.L = tr.f.R = 0;
  158.     ir.lg = blk;
  159.  
  160.     swapbyte(ir.lg);
  161.  
  162.      /* ----- permute function E ----------- */
  163.      /* rotate the 4-byte string 1 position to the right */
  164.     k = ir.ch[3] << 7;
  165.     j = (ir.ch[0] >> 1) + k;
  166.     k = ir.ch[0] << 7;
  167.     ir.ch[0] = j & 255;
  168.  
  169.     j = (ir.ch[1] >> 1) + k;
  170.     k = ir.ch[1] << 7;
  171.     ir.ch[1] = j & 255;
  172.  
  173.     j = (ir.ch[2] >> 1) + k;
  174.     k = ir.ch[2] << 7;
  175.     ir.ch[2] = j & 255;
  176.  
  177.     j = (ir.ch[3] >> 1) + k;
  178.     k = ir.ch[3] << 7;
  179.     ir.ch[3] = j & 255;
  180.  
  181.      /* ------------- DES E function -------------- */
  182.      tr.kn.ki[0] =
  183.         (ir.ch[0] & 0xfc) | ((ir.ch[0] >> 2) & 3);
  184.      tr.kn.ki[1] =
  185.         ((ir.ch[0] << 6) & 0xc0) | (((ir.ch[1] >> 2) & 0x30) |
  186.                         ((ir.ch[1] >> 4) & 0x0f));
  187.      tr.kn.ki[2] =
  188.         ((ir.ch[1] << 4) & 0xc0) | ((ir.ch[1] << 2) & 0x3c) |
  189.                         ((ir.ch[2] >> 6) & 3);
  190.      tr.kn.ki[3] =
  191.         (ir.ch[2] & 0xfc) | ((ir.ch[2] >> 2) & 3);
  192.      tr.kn.ki[4] =
  193.         ((ir.ch[2] << 6) & 0xc0) | (((ir.ch[3] >> 2) & 0x30) |
  194.                         ((ir.ch[3] >> 4) & 0x0f));
  195.      tr.kn.ki[5] =
  196.         ((ir.ch[3] << 4) & 0xc0) | ((ir.ch[3] << 2) & 0x3c) |
  197.                         ((ir.ch[0] >> 6) & 3);
  198.  
  199.     tr.f.L ^= key->L;
  200.     tr.f.R ^= key->R;
  201.  
  202.     /* ------ the DES S function: ir = S(tr.kn); ------ */
  203.  
  204.      #define S(n,op) (long)(stbl[n]                            \
  205.                              [((op >> 4) & 2) | (op & 1)]    \
  206.                              [(op >> 1) & 0xf]) << (7-n)*4;
  207.     ir.lg = 0;
  208.      op = (tr.kn.ki[0] >> 2) & 0x3f;
  209.     ir.lg |= S(0,op);
  210.  
  211.      op = ((tr.kn.ki[0] << 4) & 0x30) | ((tr.kn.ki[1] >> 4) & 0xf);
  212.     ir.lg |= S(1,op);
  213.  
  214.      op = ((tr.kn.ki[1] << 2) & 0x3c) | ((tr.kn.ki[2] >> 6) & 0x3);
  215.     ir.lg |= S(2,op);
  216.  
  217.      op = tr.kn.ki[2] & 0x3f;
  218.     ir.lg |= S(3,op);
  219.  
  220.      op = (tr.kn.ki[3] >> 2) & 0x3f;
  221.     ir.lg |= S(4,op);
  222.  
  223.      op = ((tr.kn.ki[3] << 4) & 0x30) |    ((tr.kn.ki[4] >> 4) & 0xf);
  224.     ir.lg |= S(5,op);
  225.  
  226.      op = ((tr.kn.ki[4] << 2) & 0x3c) |    ((tr.kn.ki[5] >> 6) & 0x3);
  227.     ir.lg |= S(6,op);
  228.  
  229.      op = tr.kn.ki[5] & 0x3f;
  230.     ir.lg |= S(7,op);
  231.  
  232. /* ------------------------------ */
  233.     swapbyte(ir.lg);
  234.  
  235.      /* ---------- 32 bit P permutation --------- */
  236.      {
  237.          register long *pt, *pm;
  238.          or = 0;
  239.          pt = (long *) Ptbl;
  240.          pm = (long *) P3mask;
  241.          while (pt < ((long *)Ptbl)+32)    {
  242.             if (ir.lg & *pt)
  243.                 or |= *pm;
  244.              pt++;
  245.              pm++;
  246.          }
  247.      }
  248.  
  249.      swapbyte(or);
  250.  
  251.     return or;
  252. }
  253.  
  254. /* ---------- DES Key Schedule (KS) function ----------- */
  255. static struct ks KS(int n, char *key)
  256. {
  257.     static unsigned char cd[8];
  258.     static int its[] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
  259.     union    {
  260.         struct ks kn;
  261.         struct LR filler;
  262.     } result;
  263.  
  264.     if (n == 0)
  265.         permute((long *)cd, (long *) key, (long *)PC1tbl, 64);
  266.  
  267.     rotate(cd, its[n]);
  268.     rotate(cd+4, its[n]);
  269.  
  270.     permute(&result.filler.L, (long *)cd, (long *)PC2tbl, 48);
  271.     return result.kn;
  272. }
  273.  
  274. /* rotate a 4-byte string n (1 or 2) positions to the left */
  275. static void rotate(unsigned char *c, int n)
  276. {
  277.     int i;
  278.     unsigned j, k;
  279.     k = ((*c) & 255) >> (8 - n);
  280.     for (i = 3; i >= 0; --i)    {
  281.         j = ((*(c+i) << n) + k);
  282.         k = (j >> 8) & 255;
  283.         *(c+i) = j & 255;
  284.     }
  285.     if (n == 2)
  286.        *(c+3) = (*(c+3) & 0xc0) | ((*(c+3) << 4) & 0x30);
  287.     else
  288.        *(c+3) = (*(c+3) & 0xe0) | ((*(c+3) << 4) & 0x10);
  289. }
  290.  
  291.