[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netncp/ncp_crypt.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  *  Routines in this file based on work of Volker Lendecke
    3  */
    4 /*$*********************************************************
    5    $*
    6    $* This code has been taken from DDJ 11/93, from an 
    7    $* article by Pawel Szczerbina.
    8    $*
    9    $* Password encryption routines follow.
   10    $* Converted to C from Barry Nance's Pascal
   11    $* prog published in the March -93 issue of Byte.
   12    $*
   13    $* Adapted to be useable for ncpfs by 
   14    $* Volker Lendecke <lendecke@namu01.gwdg.de> in 
   15    $* October 1995. 
   16    $*
   17    $********************************************************* */
   18 
   19 #include <sys/cdefs.h>
   20 __FBSDID("$FreeBSD$");
   21 
   22 #include <sys/param.h>
   23 #include <sys/systm.h>
   24 #include <netncp/ncp.h>
   25 #include <netncp/ncp_subr.h>
   26 
   27 typedef unsigned char buf32[32];
   28 
   29 static unsigned char encrypttable[256] = {
   30 0x7, 0x8, 0x0, 0x8, 0x6, 0x4, 0xE, 0x4, 0x5, 0xC, 0x1, 0x7, 0xB, 0xF, 0xA, 0x8,
   31 0xF, 0x8, 0xC, 0xC, 0x9, 0x4, 0x1, 0xE, 0x4, 0x6, 0x2, 0x4, 0x0, 0xA, 0xB, 0x9,
   32 0x2, 0xF, 0xB, 0x1, 0xD, 0x2, 0x1, 0x9, 0x5, 0xE, 0x7, 0x0, 0x0, 0x2, 0x6, 0x6,
   33 0x0, 0x7, 0x3, 0x8, 0x2, 0x9, 0x3, 0xF, 0x7, 0xF, 0xC, 0xF, 0x6, 0x4, 0xA, 0x0,
   34 0x2, 0x3, 0xA, 0xB, 0xD, 0x8, 0x3, 0xA, 0x1, 0x7, 0xC, 0xF, 0x1, 0x8, 0x9, 0xD,
   35 0x9, 0x1, 0x9, 0x4, 0xE, 0x4, 0xC, 0x5, 0x5, 0xC, 0x8, 0xB, 0x2, 0x3, 0x9, 0xE,
   36 0x7, 0x7, 0x6, 0x9, 0xE, 0xF, 0xC, 0x8, 0xD, 0x1, 0xA, 0x6, 0xE, 0xD, 0x0, 0x7,
   37 0x7, 0xA, 0x0, 0x1, 0xF, 0x5, 0x4, 0xB, 0x7, 0xB, 0xE, 0xC, 0x9, 0x5, 0xD, 0x1,
   38 0xB, 0xD, 0x1, 0x3, 0x5, 0xD, 0xE, 0x6, 0x3, 0x0, 0xB, 0xB, 0xF, 0x3, 0x6, 0x4,
   39 0x9, 0xD, 0xA, 0x3, 0x1, 0x4, 0x9, 0x4, 0x8, 0x3, 0xB, 0xE, 0x5, 0x0, 0x5, 0x2,
   40 0xC, 0xB, 0xD, 0x5, 0xD, 0x5, 0xD, 0x2, 0xD, 0x9, 0xA, 0xC, 0xA, 0x0, 0xB, 0x3,
   41 0x5, 0x3, 0x6, 0x9, 0x5, 0x1, 0xE, 0xE, 0x0, 0xE, 0x8, 0x2, 0xD, 0x2, 0x2, 0x0,
   42 0x4, 0xF, 0x8, 0x5, 0x9, 0x6, 0x8, 0x6, 0xB, 0xA, 0xB, 0xF, 0x0, 0x7, 0x2, 0x8,
   43 0xC, 0x7, 0x3, 0xA, 0x1, 0x4, 0x2, 0x5, 0xF, 0x7, 0xA, 0xC, 0xE, 0x5, 0x9, 0x3,
   44 0xE, 0x7, 0x1, 0x2, 0xE, 0x1, 0xF, 0x4, 0xA, 0x6, 0xC, 0x6, 0xF, 0x4, 0x3, 0x0,
   45 0xC, 0x0, 0x3, 0x6, 0xF, 0x8, 0x7, 0xB, 0x2, 0xD, 0xC, 0x6, 0xA, 0xA, 0x8, 0xD
   46 };
   47 
   48 static buf32 encryptkeys = {
   49     0x48, 0x93, 0x46, 0x67, 0x98, 0x3D, 0xE6, 0x8D,
   50     0xB7, 0x10, 0x7A, 0x26, 0x5A, 0xB9, 0xB1, 0x35,
   51     0x6B, 0x0F, 0xD5, 0x70, 0xAE, 0xFB, 0xAD, 0x11,
   52     0xF4, 0x47, 0xDC, 0xA7, 0xEC, 0xCF, 0x50, 0xC0
   53 };
   54 
   55 /*
   56  * Create table-based 16-bytes hash from a 32-bytes array
   57  */
   58 static void
   59 nw_hash(buf32 temp, unsigned char *target) {
   60         short sum;
   61         unsigned char b3;
   62         int s, b2, i;
   63 
   64         sum = 0;
   65 
   66         for (b2 = 0; b2 <= 1; ++b2) {
   67                 for (s = 0; s <= 31; ++s) {
   68                         b3 = (temp[s] + sum) ^ (temp[(s + sum) & 31] - encryptkeys[s]);
   69                         sum += b3;
   70                         temp[s] = b3;
   71                 }
   72         }
   73 
   74         for (i = 0; i <= 15; ++i) {
   75                 target[i] = encrypttable[temp[2 * i]]
   76                     | (encrypttable[temp[2 * i + 1]] << 4);
   77         }
   78 }
   79 
   80 
   81 /*
   82  * Create a 16-bytes pattern from given buffer based on a four bytes key
   83  */
   84 void
   85 nw_keyhash(const u_char *key, const u_char *buf, int buflen, u_char *target) {
   86         int b2, d, s;
   87         buf32 temp;
   88 
   89         while (buflen > 0 && buf[buflen - 1] == 0)
   90                 buflen--;
   91 
   92         bzero(temp, sizeof(temp));
   93 
   94         d = 0;
   95         while (buflen >= 32) {
   96                 for (s = 0; s <= 31; ++s)
   97                         temp[s] ^= buf[d++];
   98                 buflen -= 32;
   99         }
  100         b2 = d;
  101         if (buflen > 0) {
  102                 for (s = 0; s <= 31; ++s) {
  103                         if (d + buflen == b2) {
  104                                 temp[s] ^= encryptkeys[s];
  105                                 b2 = d;
  106                         } else
  107                                 temp[s] ^= buf[b2++];
  108                 }
  109         }
  110         for (s = 0; s <= 31; ++s)
  111                 temp[s] ^= key[s & 3];
  112 
  113         nw_hash(temp, target);
  114 }
  115 
  116 /*
  117  * Create an 8-bytes pattern from an 8-bytes key and 16-bytes of data
  118  */
  119 void
  120 nw_encrypt(const u_char *fra, const u_char *buf, u_char *target) {
  121         buf32 k;
  122         int s;
  123 
  124         nw_keyhash(fra, buf, 16, k);
  125         nw_keyhash(fra + 4, buf, 16, k + 16);
  126 
  127         for (s = 0; s < 16; s++)
  128                 k[s] ^= k[31 - s];
  129 
  130         for (s = 0; s < 8; s++)
  131                 *target++ = k[s] ^ k[15 - s];
  132 }
  133 
  134 #ifdef _KERNEL
  135 /*
  136  * MD4 routine taken from libmd sources
  137  */
  138 typedef u_int32_t       UINT4;
  139 typedef unsigned char *POINTER;
  140 
  141 #define PROTO_LIST(list) list
  142 
  143 static void Decode PROTO_LIST
  144   ((UINT4 *, const unsigned char *, unsigned int));
  145 
  146 /* Constants for MD4Transform routine.
  147  */
  148 #define S11 3
  149 #define S12 7
  150 #define S13 11
  151 #define S14 19
  152 #define S21 3
  153 #define S22 5
  154 #define S23 9
  155 #define S24 13
  156 #define S31 3
  157 #define S32 9
  158 #define S33 11
  159 #define S34 15
  160 
  161 /* F, G and H are basic MD4 functions.
  162  */
  163 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  164 #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
  165 #define H(x, y, z) ((x) ^ (y) ^ (z))
  166 
  167 /* ROTATE_LEFT rotates x left n bits.
  168  */
  169 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  170 
  171 /* FF, GG and HH are transformations for rounds 1, 2 and 3 */
  172 /* Rotation is separate from addition to prevent recomputation */
  173 #define FF(a, b, c, d, x, s) { \
  174     (a) += F ((b), (c), (d)) + (x); \
  175     (a) = ROTATE_LEFT ((a), (s)); \
  176   }
  177 #define GG(a, b, c, d, x, s) { \
  178     (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \
  179     (a) = ROTATE_LEFT ((a), (s)); \
  180   }
  181 #define HH(a, b, c, d, x, s) { \
  182     (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \
  183     (a) = ROTATE_LEFT ((a), (s)); \
  184   }
  185 
  186 void
  187 ncp_sign(const u_int32_t *state, const char *block, u_int32_t *ostate) {
  188         UINT4 a, b, c, d, x[16];
  189 
  190         Decode (x, block, 64);
  191         a = state[0];
  192         b = state[1];
  193         c = state[2];
  194         d = state[3];
  195         /* Round 1 */
  196         FF (a, b, c, d, x[ 0], S11); /* 1 */
  197         FF (d, a, b, c, x[ 1], S12); /* 2 */
  198         FF (c, d, a, b, x[ 2], S13); /* 3 */
  199         FF (b, c, d, a, x[ 3], S14); /* 4 */
  200         FF (a, b, c, d, x[ 4], S11); /* 5 */
  201         FF (d, a, b, c, x[ 5], S12); /* 6 */
  202         FF (c, d, a, b, x[ 6], S13); /* 7 */
  203         FF (b, c, d, a, x[ 7], S14); /* 8 */
  204         FF (a, b, c, d, x[ 8], S11); /* 9 */
  205         FF (d, a, b, c, x[ 9], S12); /* 10 */
  206         FF (c, d, a, b, x[10], S13); /* 11 */
  207         FF (b, c, d, a, x[11], S14); /* 12 */
  208         FF (a, b, c, d, x[12], S11); /* 13 */
  209         FF (d, a, b, c, x[13], S12); /* 14 */
  210         FF (c, d, a, b, x[14], S13); /* 15 */
  211         FF (b, c, d, a, x[15], S14); /* 16 */
  212 
  213         /* Round 2 */
  214         GG (a, b, c, d, x[ 0], S21); /* 17 */
  215         GG (d, a, b, c, x[ 4], S22); /* 18 */
  216         GG (c, d, a, b, x[ 8], S23); /* 19 */
  217         GG (b, c, d, a, x[12], S24); /* 20 */
  218         GG (a, b, c, d, x[ 1], S21); /* 21 */
  219         GG (d, a, b, c, x[ 5], S22); /* 22 */
  220         GG (c, d, a, b, x[ 9], S23); /* 23 */
  221         GG (b, c, d, a, x[13], S24); /* 24 */
  222         GG (a, b, c, d, x[ 2], S21); /* 25 */
  223         GG (d, a, b, c, x[ 6], S22); /* 26 */
  224         GG (c, d, a, b, x[10], S23); /* 27 */
  225         GG (b, c, d, a, x[14], S24); /* 28 */
  226         GG (a, b, c, d, x[ 3], S21); /* 29 */
  227         GG (d, a, b, c, x[ 7], S22); /* 30 */
  228         GG (c, d, a, b, x[11], S23); /* 31 */
  229         GG (b, c, d, a, x[15], S24); /* 32 */
  230 
  231         /* Round 3 */
  232         HH (a, b, c, d, x[ 0], S31); /* 33 */
  233         HH (d, a, b, c, x[ 8], S32); /* 34 */
  234         HH (c, d, a, b, x[ 4], S33); /* 35 */
  235         HH (b, c, d, a, x[12], S34); /* 36 */
  236         HH (a, b, c, d, x[ 2], S31); /* 37 */
  237         HH (d, a, b, c, x[10], S32); /* 38 */
  238         HH (c, d, a, b, x[ 6], S33); /* 39 */
  239         HH (b, c, d, a, x[14], S34); /* 40 */
  240         HH (a, b, c, d, x[ 1], S31); /* 41 */
  241         HH (d, a, b, c, x[ 9], S32); /* 42 */
  242         HH (c, d, a, b, x[ 5], S33); /* 43 */
  243         HH (b, c, d, a, x[13], S34); /* 44 */
  244         HH (a, b, c, d, x[ 3], S31); /* 45 */
  245         HH (d, a, b, c, x[11], S32); /* 46 */
  246         HH (c, d, a, b, x[ 7], S33); /* 47 */
  247         HH (b, c, d, a, x[15], S34); /* 48 */
  248 
  249         ostate[0] = state[0] + a;
  250         ostate[1] = state[1] + b;
  251         ostate[2] = state[2] + c;
  252         ostate[3] = state[3] + d;
  253 }
  254 
  255 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
  256      a multiple of 4.
  257  */
  258 static void Decode (output, input, len)
  259 
  260 UINT4 *output;
  261 const unsigned char *input;
  262 unsigned int len;
  263 {
  264   unsigned int i, j;
  265 
  266   for (i = 0, j = 0; j < len; i++, j += 4)
  267     output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
  268       (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
  269 }
  270 
  271 #endif /* _KERNEL */

Cache object: 0f0a9e6bd90beeeabd6948269a70be7e


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.