git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/CyaSSL/ctaocrypt/src/ripemd.c

   1 /* ripemd.c
   2  *
   3  * Copyright (C) 2006-2014 wolfSSL Inc.
   4  *
   5  * This file is part of CyaSSL.
   6  *
   7  * CyaSSL is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * CyaSSL is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22
  23 #ifdef HAVE_CONFIG_H
  24     #include <config.h>
  25 #endif
  26
  27 #include <cyassl/ctaocrypt/settings.h>
  28
  29 #ifdef CYASSL_RIPEMD
  30
  31 #include <cyassl/ctaocrypt/ripemd.h>
  32 #ifdef NO_INLINE
  33     #include <cyassl/ctaocrypt/misc.h>
  34 #else
  35     #include <ctaocrypt/src/misc.c>
  36 #endif
  37
  38
  39 #ifndef min
  40
  41     static INLINE word32 min(word32 a, word32 b)
  42     {
  43         return a > b ? b : a;
  44     }
  45
  46 #endif /* min */
  47
  48
  49 void InitRipeMd(RipeMd* ripemd)
  50 {
  51     ripemd->digest[0] = 0x67452301L;
  52     ripemd->digest[1] = 0xEFCDAB89L;
  53     ripemd->digest[2] = 0x98BADCFEL;
  54     ripemd->digest[3] = 0x10325476L;
  55     ripemd->digest[4] = 0xC3D2E1F0L;
  56
  57     ripemd->buffLen = 0;
  58     ripemd->loLen   = 0;
  59     ripemd->hiLen   = 0;
  60 }
  61
  62
  63 /* for all */
  64 #define F(x, y, z)    (x ^ y ^ z)
  65 #define G(x, y, z)    (z ^ (x & (y^z)))
  66 #define H(x, y, z)    (z ^ (x | ~y))
  67 #define I(x, y, z)    (y ^ (z & (x^y)))
  68 #define J(x, y, z)    (x ^ (y | ~z))
  69
  70 #define k0 0
  71 #define k1 0x5a827999
  72 #define k2 0x6ed9eba1
  73 #define k3 0x8f1bbcdc
  74 #define k4 0xa953fd4e
  75 #define k5 0x50a28be6
  76 #define k6 0x5c4dd124
  77 #define k7 0x6d703ef3
  78 #define k8 0x7a6d76e9
  79 #define k9 0
  80
  81 /* for 160 and 320 */
  82 #define Subround(f, a, b, c, d, e, x, s, k) \
  83     a += f(b, c, d) + x + k;\
  84     a = rotlFixed((word32)a, s) + e;\
  85     c = rotlFixed((word32)c, 10U)
  86
  87 static void Transform(RipeMd* ripemd)
  88 {
  89     word32 a1, b1, c1, d1, e1, a2, b2, c2, d2, e2;
  90     a1 = a2 = ripemd->digest[0];
  91     b1 = b2 = ripemd->digest[1];
  92     c1 = c2 = ripemd->digest[2];
  93     d1 = d2 = ripemd->digest[3];
  94     e1 = e2 = ripemd->digest[4];
  95
  96     Subround(F, a1, b1, c1, d1, e1, ripemd->buffer[ 0], 11, k0);
  97     Subround(F, e1, a1, b1, c1, d1, ripemd->buffer[ 1], 14, k0);
  98     Subround(F, d1, e1, a1, b1, c1, ripemd->buffer[ 2], 15, k0);
  99     Subround(F, c1, d1, e1, a1, b1, ripemd->buffer[ 3], 12, k0);
 100     Subround(F, b1, c1, d1, e1, a1, ripemd->buffer[ 4],  5, k0);
 101     Subround(F, a1, b1, c1, d1, e1, ripemd->buffer[ 5],  8, k0);
 102     Subround(F, e1, a1, b1, c1, d1, ripemd->buffer[ 6],  7, k0);
 103     Subround(F, d1, e1, a1, b1, c1, ripemd->buffer[ 7],  9, k0);
 104     Subround(F, c1, d1, e1, a1, b1, ripemd->buffer[ 8], 11, k0);
 105     Subround(F, b1, c1, d1, e1, a1, ripemd->buffer[ 9], 13, k0);
 106     Subround(F, a1, b1, c1, d1, e1, ripemd->buffer[10], 14, k0);
 107     Subround(F, e1, a1, b1, c1, d1, ripemd->buffer[11], 15, k0);
 108     Subround(F, d1, e1, a1, b1, c1, ripemd->buffer[12],  6, k0);
 109     Subround(F, c1, d1, e1, a1, b1, ripemd->buffer[13],  7, k0);
 110     Subround(F, b1, c1, d1, e1, a1, ripemd->buffer[14],  9, k0);
 111     Subround(F, a1, b1, c1, d1, e1, ripemd->buffer[15],  8, k0);
 112
 113     Subround(G, e1, a1, b1, c1, d1, ripemd->buffer[ 7],  7, k1);
 114     Subround(G, d1, e1, a1, b1, c1, ripemd->buffer[ 4],  6, k1);
 115     Subround(G, c1, d1, e1, a1, b1, ripemd->buffer[13],  8, k1);
 116     Subround(G, b1, c1, d1, e1, a1, ripemd->buffer[ 1], 13, k1);
 117     Subround(G, a1, b1, c1, d1, e1, ripemd->buffer[10], 11, k1);
 118     Subround(G, e1, a1, b1, c1, d1, ripemd->buffer[ 6],  9, k1);
 119     Subround(G, d1, e1, a1, b1, c1, ripemd->buffer[15],  7, k1);
 120     Subround(G, c1, d1, e1, a1, b1, ripemd->buffer[ 3], 15, k1);
 121     Subround(G, b1, c1, d1, e1, a1, ripemd->buffer[12],  7, k1);
 122     Subround(G, a1, b1, c1, d1, e1, ripemd->buffer[ 0], 12, k1);
 123     Subround(G, e1, a1, b1, c1, d1, ripemd->buffer[ 9], 15, k1);
 124     Subround(G, d1, e1, a1, b1, c1, ripemd->buffer[ 5],  9, k1);
 125     Subround(G, c1, d1, e1, a1, b1, ripemd->buffer[ 2], 11, k1);
 126     Subround(G, b1, c1, d1, e1, a1, ripemd->buffer[14],  7, k1);
 127     Subround(G, a1, b1, c1, d1, e1, ripemd->buffer[11], 13, k1);
 128     Subround(G, e1, a1, b1, c1, d1, ripemd->buffer[ 8], 12, k1);
 129
 130     Subround(H, d1, e1, a1, b1, c1, ripemd->buffer[ 3], 11, k2);
 131     Subround(H, c1, d1, e1, a1, b1, ripemd->buffer[10], 13, k2);
 132     Subround(H, b1, c1, d1, e1, a1, ripemd->buffer[14],  6, k2);
 133     Subround(H, a1, b1, c1, d1, e1, ripemd->buffer[ 4],  7, k2);
 134     Subround(H, e1, a1, b1, c1, d1, ripemd->buffer[ 9], 14, k2);
 135     Subround(H, d1, e1, a1, b1, c1, ripemd->buffer[15],  9, k2);
 136     Subround(H, c1, d1, e1, a1, b1, ripemd->buffer[ 8], 13, k2);
 137     Subround(H, b1, c1, d1, e1, a1, ripemd->buffer[ 1], 15, k2);
 138     Subround(H, a1, b1, c1, d1, e1, ripemd->buffer[ 2], 14, k2);
 139     Subround(H, e1, a1, b1, c1, d1, ripemd->buffer[ 7],  8, k2);
 140     Subround(H, d1, e1, a1, b1, c1, ripemd->buffer[ 0], 13, k2);
 141     Subround(H, c1, d1, e1, a1, b1, ripemd->buffer[ 6],  6, k2);
 142     Subround(H, b1, c1, d1, e1, a1, ripemd->buffer[13],  5, k2);
 143     Subround(H, a1, b1, c1, d1, e1, ripemd->buffer[11], 12, k2);
 144     Subround(H, e1, a1, b1, c1, d1, ripemd->buffer[ 5],  7, k2);
 145     Subround(H, d1, e1, a1, b1, c1, ripemd->buffer[12],  5, k2);
 146
 147     Subround(I, c1, d1, e1, a1, b1, ripemd->buffer[ 1], 11, k3);
 148     Subround(I, b1, c1, d1, e1, a1, ripemd->buffer[ 9], 12, k3);
 149     Subround(I, a1, b1, c1, d1, e1, ripemd->buffer[11], 14, k3);
 150     Subround(I, e1, a1, b1, c1, d1, ripemd->buffer[10], 15, k3);
 151     Subround(I, d1, e1, a1, b1, c1, ripemd->buffer[ 0], 14, k3);
 152     Subround(I, c1, d1, e1, a1, b1, ripemd->buffer[ 8], 15, k3);
 153     Subround(I, b1, c1, d1, e1, a1, ripemd->buffer[12],  9, k3);
 154     Subround(I, a1, b1, c1, d1, e1, ripemd->buffer[ 4],  8, k3);
 155     Subround(I, e1, a1, b1, c1, d1, ripemd->buffer[13],  9, k3);
 156     Subround(I, d1, e1, a1, b1, c1, ripemd->buffer[ 3], 14, k3);
 157     Subround(I, c1, d1, e1, a1, b1, ripemd->buffer[ 7],  5, k3);
 158     Subround(I, b1, c1, d1, e1, a1, ripemd->buffer[15],  6, k3);
 159     Subround(I, a1, b1, c1, d1, e1, ripemd->buffer[14],  8, k3);
 160     Subround(I, e1, a1, b1, c1, d1, ripemd->buffer[ 5],  6, k3);
 161     Subround(I, d1, e1, a1, b1, c1, ripemd->buffer[ 6],  5, k3);
 162     Subround(I, c1, d1, e1, a1, b1, ripemd->buffer[ 2], 12, k3);
 163
 164     Subround(J, b1, c1, d1, e1, a1, ripemd->buffer[ 4],  9, k4);
 165     Subround(J, a1, b1, c1, d1, e1, ripemd->buffer[ 0], 15, k4);
 166     Subround(J, e1, a1, b1, c1, d1, ripemd->buffer[ 5],  5, k4);
 167     Subround(J, d1, e1, a1, b1, c1, ripemd->buffer[ 9], 11, k4);
 168     Subround(J, c1, d1, e1, a1, b1, ripemd->buffer[ 7],  6, k4);
 169     Subround(J, b1, c1, d1, e1, a1, ripemd->buffer[12],  8, k4);
 170     Subround(J, a1, b1, c1, d1, e1, ripemd->buffer[ 2], 13, k4);
 171     Subround(J, e1, a1, b1, c1, d1, ripemd->buffer[10], 12, k4);
 172     Subround(J, d1, e1, a1, b1, c1, ripemd->buffer[14],  5, k4);
 173     Subround(J, c1, d1, e1, a1, b1, ripemd->buffer[ 1], 12, k4);
 174     Subround(J, b1, c1, d1, e1, a1, ripemd->buffer[ 3], 13, k4);
 175     Subround(J, a1, b1, c1, d1, e1, ripemd->buffer[ 8], 14, k4);
 176     Subround(J, e1, a1, b1, c1, d1, ripemd->buffer[11], 11, k4);
 177     Subround(J, d1, e1, a1, b1, c1, ripemd->buffer[ 6],  8, k4);
 178     Subround(J, c1, d1, e1, a1, b1, ripemd->buffer[15],  5, k4);
 179     Subround(J, b1, c1, d1, e1, a1, ripemd->buffer[13],  6, k4);
 180
 181     Subround(J, a2, b2, c2, d2, e2, ripemd->buffer[ 5],  8, k5);
 182     Subround(J, e2, a2, b2, c2, d2, ripemd->buffer[14],  9, k5);
 183     Subround(J, d2, e2, a2, b2, c2, ripemd->buffer[ 7],  9, k5);
 184     Subround(J, c2, d2, e2, a2, b2, ripemd->buffer[ 0], 11, k5);
 185     Subround(J, b2, c2, d2, e2, a2, ripemd->buffer[ 9], 13, k5);
 186     Subround(J, a2, b2, c2, d2, e2, ripemd->buffer[ 2], 15, k5);
 187     Subround(J, e2, a2, b2, c2, d2, ripemd->buffer[11], 15, k5);
 188     Subround(J, d2, e2, a2, b2, c2, ripemd->buffer[ 4],  5, k5);
 189     Subround(J, c2, d2, e2, a2, b2, ripemd->buffer[13],  7, k5);
 190     Subround(J, b2, c2, d2, e2, a2, ripemd->buffer[ 6],  7, k5);
 191     Subround(J, a2, b2, c2, d2, e2, ripemd->buffer[15],  8, k5);
 192     Subround(J, e2, a2, b2, c2, d2, ripemd->buffer[ 8], 11, k5);
 193     Subround(J, d2, e2, a2, b2, c2, ripemd->buffer[ 1], 14, k5);
 194     Subround(J, c2, d2, e2, a2, b2, ripemd->buffer[10], 14, k5);
 195     Subround(J, b2, c2, d2, e2, a2, ripemd->buffer[ 3], 12, k5);
 196     Subround(J, a2, b2, c2, d2, e2, ripemd->buffer[12],  6, k5);
 197
 198     Subround(I, e2, a2, b2, c2, d2, ripemd->buffer[ 6],  9, k6);
 199     Subround(I, d2, e2, a2, b2, c2, ripemd->buffer[11], 13, k6);
 200     Subround(I, c2, d2, e2, a2, b2, ripemd->buffer[ 3], 15, k6);
 201     Subround(I, b2, c2, d2, e2, a2, ripemd->buffer[ 7],  7, k6);
 202     Subround(I, a2, b2, c2, d2, e2, ripemd->buffer[ 0], 12, k6);
 203     Subround(I, e2, a2, b2, c2, d2, ripemd->buffer[13],  8, k6);
 204     Subround(I, d2, e2, a2, b2, c2, ripemd->buffer[ 5],  9, k6);
 205     Subround(I, c2, d2, e2, a2, b2, ripemd->buffer[10], 11, k6);
 206     Subround(I, b2, c2, d2, e2, a2, ripemd->buffer[14],  7, k6);
 207     Subround(I, a2, b2, c2, d2, e2, ripemd->buffer[15],  7, k6);
 208     Subround(I, e2, a2, b2, c2, d2, ripemd->buffer[ 8], 12, k6);
 209     Subround(I, d2, e2, a2, b2, c2, ripemd->buffer[12],  7, k6);
 210     Subround(I, c2, d2, e2, a2, b2, ripemd->buffer[ 4],  6, k6);
 211     Subround(I, b2, c2, d2, e2, a2, ripemd->buffer[ 9], 15, k6);
 212     Subround(I, a2, b2, c2, d2, e2, ripemd->buffer[ 1], 13, k6);
 213     Subround(I, e2, a2, b2, c2, d2, ripemd->buffer[ 2], 11, k6);
 214
 215     Subround(H, d2, e2, a2, b2, c2, ripemd->buffer[15],  9, k7);
 216     Subround(H, c2, d2, e2, a2, b2, ripemd->buffer[ 5],  7, k7);
 217     Subround(H, b2, c2, d2, e2, a2, ripemd->buffer[ 1], 15, k7);
 218     Subround(H, a2, b2, c2, d2, e2, ripemd->buffer[ 3], 11, k7);
 219     Subround(H, e2, a2, b2, c2, d2, ripemd->buffer[ 7],  8, k7);
 220     Subround(H, d2, e2, a2, b2, c2, ripemd->buffer[14],  6, k7);
 221     Subround(H, c2, d2, e2, a2, b2, ripemd->buffer[ 6],  6, k7);
 222     Subround(H, b2, c2, d2, e2, a2, ripemd->buffer[ 9], 14, k7);
 223     Subround(H, a2, b2, c2, d2, e2, ripemd->buffer[11], 12, k7);
 224     Subround(H, e2, a2, b2, c2, d2, ripemd->buffer[ 8], 13, k7);
 225     Subround(H, d2, e2, a2, b2, c2, ripemd->buffer[12],  5, k7);
 226     Subround(H, c2, d2, e2, a2, b2, ripemd->buffer[ 2], 14, k7);
 227     Subround(H, b2, c2, d2, e2, a2, ripemd->buffer[10], 13, k7);
 228     Subround(H, a2, b2, c2, d2, e2, ripemd->buffer[ 0], 13, k7);
 229     Subround(H, e2, a2, b2, c2, d2, ripemd->buffer[ 4],  7, k7);
 230     Subround(H, d2, e2, a2, b2, c2, ripemd->buffer[13],  5, k7);
 231
 232     Subround(G, c2, d2, e2, a2, b2, ripemd->buffer[ 8], 15, k8);
 233     Subround(G, b2, c2, d2, e2, a2, ripemd->buffer[ 6],  5, k8);
 234     Subround(G, a2, b2, c2, d2, e2, ripemd->buffer[ 4],  8, k8);
 235     Subround(G, e2, a2, b2, c2, d2, ripemd->buffer[ 1], 11, k8);
 236     Subround(G, d2, e2, a2, b2, c2, ripemd->buffer[ 3], 14, k8);
 237     Subround(G, c2, d2, e2, a2, b2, ripemd->buffer[11], 14, k8);
 238     Subround(G, b2, c2, d2, e2, a2, ripemd->buffer[15],  6, k8);
 239     Subround(G, a2, b2, c2, d2, e2, ripemd->buffer[ 0], 14, k8);
 240     Subround(G, e2, a2, b2, c2, d2, ripemd->buffer[ 5],  6, k8);
 241     Subround(G, d2, e2, a2, b2, c2, ripemd->buffer[12],  9, k8);
 242     Subround(G, c2, d2, e2, a2, b2, ripemd->buffer[ 2], 12, k8);
 243     Subround(G, b2, c2, d2, e2, a2, ripemd->buffer[13],  9, k8);
 244     Subround(G, a2, b2, c2, d2, e2, ripemd->buffer[ 9], 12, k8);
 245     Subround(G, e2, a2, b2, c2, d2, ripemd->buffer[ 7],  5, k8);
 246     Subround(G, d2, e2, a2, b2, c2, ripemd->buffer[10], 15, k8);
 247     Subround(G, c2, d2, e2, a2, b2, ripemd->buffer[14],  8, k8);
 248
 249     Subround(F, b2, c2, d2, e2, a2, ripemd->buffer[12],  8, k9);
 250     Subround(F, a2, b2, c2, d2, e2, ripemd->buffer[15],  5, k9);
 251     Subround(F, e2, a2, b2, c2, d2, ripemd->buffer[10], 12, k9);
 252     Subround(F, d2, e2, a2, b2, c2, ripemd->buffer[ 4],  9, k9);
 253     Subround(F, c2, d2, e2, a2, b2, ripemd->buffer[ 1], 12, k9);
 254     Subround(F, b2, c2, d2, e2, a2, ripemd->buffer[ 5],  5, k9);
 255     Subround(F, a2, b2, c2, d2, e2, ripemd->buffer[ 8], 14, k9);
 256     Subround(F, e2, a2, b2, c2, d2, ripemd->buffer[ 7],  6, k9);
 257     Subround(F, d2, e2, a2, b2, c2, ripemd->buffer[ 6],  8, k9);
 258     Subround(F, c2, d2, e2, a2, b2, ripemd->buffer[ 2], 13, k9);
 259     Subround(F, b2, c2, d2, e2, a2, ripemd->buffer[13],  6, k9);
 260     Subround(F, a2, b2, c2, d2, e2, ripemd->buffer[14],  5, k9);
 261     Subround(F, e2, a2, b2, c2, d2, ripemd->buffer[ 0], 15, k9);
 262     Subround(F, d2, e2, a2, b2, c2, ripemd->buffer[ 3], 13, k9);
 263     Subround(F, c2, d2, e2, a2, b2, ripemd->buffer[ 9], 11, k9);
 264     Subround(F, b2, c2, d2, e2, a2, ripemd->buffer[11], 11, k9);
 265
 266     c1                = ripemd->digest[1] + c1 + d2;
 267     ripemd->digest[1] = ripemd->digest[2] + d1 + e2;
 268     ripemd->digest[2] = ripemd->digest[3] + e1 + a2;
 269     ripemd->digest[3] = ripemd->digest[4] + a1 + b2;
 270     ripemd->digest[4] = ripemd->digest[0] + b1 + c2;
 271     ripemd->digest[0] = c1;
 272 }
 273
 274
 275 static INLINE void AddLength(RipeMd* ripemd, word32 len)
 276 {
 277     word32 tmp = ripemd->loLen;
 278     if ( (ripemd->loLen += len) < tmp)
 279         ripemd->hiLen++;                       /* carry low to high */
 280 }
 281
 282
 283 void RipeMdUpdate(RipeMd* ripemd, const byte* data, word32 len)
 284 {
 285     /* do block size increments */
 286     byte* local = (byte*)ripemd->buffer;
 287
 288     while (len) {
 289         word32 add = min(len, RIPEMD_BLOCK_SIZE - ripemd->buffLen);
 290         XMEMCPY(&local[ripemd->buffLen], data, add);
 291
 292         ripemd->buffLen += add;
 293         data         += add;
 294         len          -= add;
 295
 296         if (ripemd->buffLen == RIPEMD_BLOCK_SIZE) {
 297             #ifdef BIG_ENDIAN_ORDER
 298                 ByteReverseWords(ripemd->buffer, ripemd->buffer,
 299                                  RIPEMD_BLOCK_SIZE);
 300             #endif
 301             Transform(ripemd);
 302             AddLength(ripemd, RIPEMD_BLOCK_SIZE);
 303             ripemd->buffLen = 0;
 304         }
 305     }
 306 }
 307
 308
 309 void RipeMdFinal(RipeMd* ripemd, byte* hash)
 310 {
 311     byte* local = (byte*)ripemd->buffer;
 312
 313     AddLength(ripemd, ripemd->buffLen);               /* before adding pads */
 314
 315     local[ripemd->buffLen++] = 0x80;  /* add 1 */
 316
 317     /* pad with zeros */
 318     if (ripemd->buffLen > RIPEMD_PAD_SIZE) {
 319         XMEMSET(&local[ripemd->buffLen], 0, RIPEMD_BLOCK_SIZE - ripemd->buffLen);
 320         ripemd->buffLen += RIPEMD_BLOCK_SIZE - ripemd->buffLen;
 321
 322         #ifdef BIG_ENDIAN_ORDER
 323             ByteReverseWords(ripemd->buffer, ripemd->buffer, RIPEMD_BLOCK_SIZE);
 324         #endif
 325         Transform(ripemd);
 326         ripemd->buffLen = 0;
 327     }
 328     XMEMSET(&local[ripemd->buffLen], 0, RIPEMD_PAD_SIZE - ripemd->buffLen);
 329
 330     /* put lengths in bits */
 331     ripemd->loLen = ripemd->loLen << 3;
 332     ripemd->hiLen = (ripemd->loLen >> (8*sizeof(ripemd->loLen) - 3)) +
 333                  (ripemd->hiLen << 3);
 334
 335     /* store lengths */
 336     #ifdef BIG_ENDIAN_ORDER
 337         ByteReverseWords(ripemd->buffer, ripemd->buffer, RIPEMD_BLOCK_SIZE);
 338     #endif
 339     /* ! length ordering dependent on digest endian type ! */
 340     XMEMCPY(&local[RIPEMD_PAD_SIZE], &ripemd->loLen, sizeof(word32));
 341     XMEMCPY(&local[RIPEMD_PAD_SIZE + sizeof(word32)], &ripemd->hiLen,
 342            sizeof(word32));
 343
 344     Transform(ripemd);
 345     #ifdef BIG_ENDIAN_ORDER
 346         ByteReverseWords(ripemd->digest, ripemd->digest, RIPEMD_DIGEST_SIZE);
 347     #endif
 348     XMEMCPY(hash, ripemd->digest, RIPEMD_DIGEST_SIZE);
 349
 350     InitRipeMd(ripemd);  /* reset state */
 351 }
 352
 353
 354 #endif /* CYASSL_RIPEMD */