mdfour.c

   1 /*
   2    a implementation of MD4 designed for use in the SMB authentication protocol
   3    Copyright (C) Andrew Tridgell 1997-1998.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include "mdfour.h"
  22
  23 /* NOTE: This code makes no attempt to be fast!
  24
  25    It assumes that a int is at least 32 bits long
  26 */
  27
  28 #define MASK32 (0xffffffff)
  29
  30 #define F(X,Y,Z) ((((X)&(Y)) | ((~(X))&(Z))))
  31 #define G(X,Y,Z) ((((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z))))
  32 #define H(X,Y,Z) (((X)^(Y)^(Z)))
  33 #define lshift(x,s) (((((x)<<(s))&MASK32) | (((x)>>(32-(s)))&MASK32)))
  34
  35 #define ROUND1(a,b,c,d,k,s) a = lshift((a + F(b,c,d) + M[k])&MASK32, s)
  36 #define ROUND2(a,b,c,d,k,s) a = lshift((a + G(b,c,d) + M[k] + 0x5A827999)&MASK32,s)
  37 #define ROUND3(a,b,c,d,k,s) a = lshift((a + H(b,c,d) + M[k] + 0x6ED9EBA1)&MASK32,s)
  38
  39 /* this applies md4 to 64 byte chunks */
  40 static void
  41 mdfour64(struct mdfour *m, uint32_t *M)
  42 {
  43   uint32_t AA, BB, CC, DD;
  44   uint32_t A,B,C,D;
  45
  46   A = m->A; B = m->B; C = m->C; D = m->D;
  47   AA = A; BB = B; CC = C; DD = D;
  48
  49   ROUND1(A,B,C,D,  0,  3);  ROUND1(D,A,B,C,  1,  7);
  50   ROUND1(C,D,A,B,  2, 11);  ROUND1(B,C,D,A,  3, 19);
  51   ROUND1(A,B,C,D,  4,  3);  ROUND1(D,A,B,C,  5,  7);
  52   ROUND1(C,D,A,B,  6, 11);  ROUND1(B,C,D,A,  7, 19);
  53   ROUND1(A,B,C,D,  8,  3);  ROUND1(D,A,B,C,  9,  7);
  54   ROUND1(C,D,A,B, 10, 11);  ROUND1(B,C,D,A, 11, 19);
  55   ROUND1(A,B,C,D, 12,  3);  ROUND1(D,A,B,C, 13,  7);
  56   ROUND1(C,D,A,B, 14, 11);  ROUND1(B,C,D,A, 15, 19);
  57
  58
  59   ROUND2(A,B,C,D,  0,  3);  ROUND2(D,A,B,C,  4,  5);
  60   ROUND2(C,D,A,B,  8,  9);  ROUND2(B,C,D,A, 12, 13);
  61   ROUND2(A,B,C,D,  1,  3);  ROUND2(D,A,B,C,  5,  5);
  62   ROUND2(C,D,A,B,  9,  9);  ROUND2(B,C,D,A, 13, 13);
  63   ROUND2(A,B,C,D,  2,  3);  ROUND2(D,A,B,C,  6,  5);
  64   ROUND2(C,D,A,B, 10,  9);  ROUND2(B,C,D,A, 14, 13);
  65   ROUND2(A,B,C,D,  3,  3);  ROUND2(D,A,B,C,  7,  5);
  66   ROUND2(C,D,A,B, 11,  9);  ROUND2(B,C,D,A, 15, 13);
  67
  68   ROUND3(A,B,C,D,  0,  3);  ROUND3(D,A,B,C,  8,  9);
  69   ROUND3(C,D,A,B,  4, 11);  ROUND3(B,C,D,A, 12, 15);
  70   ROUND3(A,B,C,D,  2,  3);  ROUND3(D,A,B,C, 10,  9);
  71   ROUND3(C,D,A,B,  6, 11);  ROUND3(B,C,D,A, 14, 15);
  72   ROUND3(A,B,C,D,  1,  3);  ROUND3(D,A,B,C,  9,  9);
  73   ROUND3(C,D,A,B,  5, 11);  ROUND3(B,C,D,A, 13, 15);
  74   ROUND3(A,B,C,D,  3,  3);  ROUND3(D,A,B,C, 11,  9);
  75   ROUND3(C,D,A,B,  7, 11);  ROUND3(B,C,D,A, 15, 15);
  76
  77   A += AA; B += BB;
  78   C += CC; D += DD;
  79
  80   A &= MASK32; B &= MASK32;
  81   C &= MASK32; D &= MASK32;
  82
  83   m->A = A; m->B = B; m->C = C; m->D = D;
  84 }
  85
  86 static void
  87 copy64(uint32_t *M, const unsigned char *in)
  88 {
  89   int i;
  90
  91   for (i=0;i<16;i++)
  92     M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
  93       (in[i*4+1]<<8) | (in[i*4+0]<<0);
  94 }
  95
  96 static void
  97 copy4(unsigned char *out,uint32_t x)
  98 {
  99   out[0] = x&0xFF;
 100   out[1] = (x>>8)&0xFF;
 101   out[2] = (x>>16)&0xFF;
 102   out[3] = (x>>24)&0xFF;
 103 }
 104
 105 void
 106 mdfour_begin(struct mdfour *md)
 107 {
 108   md->A = 0x67452301;
 109   md->B = 0xefcdab89;
 110   md->C = 0x98badcfe;
 111   md->D = 0x10325476;
 112   md->totalN = 0;
 113   md->tail_len = 0;
 114 }
 115
 116
 117 static void
 118 mdfour_tail(struct mdfour *m, const unsigned char *in, int n)
 119 {
 120   unsigned char buf[128];
 121   uint32_t M[16];
 122   uint32_t b;
 123
 124   m->totalN += n;
 125
 126   b = m->totalN * 8;
 127
 128   memset(buf, 0, 128);
 129   if (n) memcpy(buf, in, n);
 130   buf[n] = 0x80;
 131
 132   if (n <= 55)
 133     {
 134       copy4(buf+56, b);
 135       copy64(M, buf);
 136       mdfour64(m, M);
 137     }
 138   else
 139     {
 140       copy4(buf+120, b);
 141       copy64(M, buf);
 142       mdfour64(m, M);
 143       copy64(M, buf+64);
 144       mdfour64(m, M);
 145     }
 146 }
 147
 148 void
 149 mdfour_update(struct mdfour *md, const unsigned char *in, int n)
 150 {
 151   uint32_t M[16];
 152
 153   if (in == NULL)
 154     {
 155       mdfour_tail(md, md->tail, md->tail_len);
 156       return;
 157     }
 158
 159   if (md->tail_len)
 160     {
 161       int len = 64 - md->tail_len;
 162       if (len > n) len = n;
 163       memcpy(md->tail+md->tail_len, in, len);
 164       md->tail_len += len;
 165       n -= len;
 166       in += len;
 167       if (md->tail_len == 64)
 168         {
 169           copy64(M, md->tail);
 170           mdfour64(md, M);
 171           md->totalN += 64;
 172           md->tail_len = 0;
 173         }
 174     }
 175
 176     while (n >= 64)
 177       {
 178         copy64(M, in);
 179         mdfour64(md, M);
 180         in += 64;
 181         n -= 64;
 182         md->totalN += 64;
 183       }
 184
 185     if (n)
 186       {
 187         memcpy(md->tail, in, n);
 188         md->tail_len = n;
 189       }
 190 }
 191
 192
 193 void
 194 mdfour_result(struct mdfour *md, unsigned char *out)
 195 {
 196   copy4(out, md->A);
 197   copy4(out+4, md->B);
 198   copy4(out+8, md->C);
 199   copy4(out+12, md->D);
 200 }
 201
 202
 203 void
 204 mdfour(unsigned char *out, const unsigned char *in, int n)
 205 {
 206   struct mdfour md;
 207   mdfour_begin(&md);
 208   mdfour_update(&md, in, n);
 209   mdfour_update(&md, NULL, 0);
 210   mdfour_result(&md, out);
 211 }
 212
 213 /* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */