wp_dgst.c (256281) | wp_dgst.c (280304) |
---|---|
1/** 2 * The Whirlpool hashing function. 3 * 4 * <P> 5 * <b>References</b> 6 * 7 * <P> 8 * The Whirlpool algorithm was developed by --- 42 unchanged lines hidden (view full) --- 51 * input. This is done for perfomance. 52 */ 53 54#include "wp_locl.h" 55#include <openssl/crypto.h> 56#include <string.h> 57 58fips_md_init(WHIRLPOOL) | 1/** 2 * The Whirlpool hashing function. 3 * 4 * <P> 5 * <b>References</b> 6 * 7 * <P> 8 * The Whirlpool algorithm was developed by --- 42 unchanged lines hidden (view full) --- 51 * input. This is done for perfomance. 52 */ 53 54#include "wp_locl.h" 55#include <openssl/crypto.h> 56#include <string.h> 57 58fips_md_init(WHIRLPOOL) |
59 { 60 memset (c,0,sizeof(*c)); 61 return(1); 62 } | 59{ 60 memset(c, 0, sizeof(*c)); 61 return (1); 62} |
63 | 63 |
64int WHIRLPOOL_Update (WHIRLPOOL_CTX *c,const void *_inp,size_t bytes) 65 { 66 /* Well, largest suitable chunk size actually is 67 * (1<<(sizeof(size_t)*8-3))-64, but below number 68 * is large enough for not to care about excessive 69 * calls to WHIRLPOOL_BitUpdate... */ 70 size_t chunk = ((size_t)1)<<(sizeof(size_t)*8-4); 71 const unsigned char *inp = _inp; | 64int WHIRLPOOL_Update(WHIRLPOOL_CTX *c, const void *_inp, size_t bytes) 65{ 66 /* 67 * Well, largest suitable chunk size actually is 68 * (1<<(sizeof(size_t)*8-3))-64, but below number is large enough for not 69 * to care about excessive calls to WHIRLPOOL_BitUpdate... 70 */ 71 size_t chunk = ((size_t)1) << (sizeof(size_t) * 8 - 4); 72 const unsigned char *inp = _inp; |
72 | 73 |
73 while (bytes>=chunk) 74 { 75 WHIRLPOOL_BitUpdate(c,inp,chunk*8); 76 bytes -= chunk; 77 inp += chunk; 78 } 79 if (bytes) 80 WHIRLPOOL_BitUpdate(c,inp,bytes*8); | 74 while (bytes >= chunk) { 75 WHIRLPOOL_BitUpdate(c, inp, chunk * 8); 76 bytes -= chunk; 77 inp += chunk; 78 } 79 if (bytes) 80 WHIRLPOOL_BitUpdate(c, inp, bytes * 8); |
81 | 81 |
82 return(1); 83 } | 82 return (1); 83} |
84 | 84 |
85void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,const void *_inp,size_t bits) 86 { 87 size_t n; 88 unsigned int bitoff = c->bitoff, 89 bitrem = bitoff%8, 90 inpgap = (8-(unsigned int)bits%8)&7; 91 const unsigned char *inp=_inp; | 85void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c, const void *_inp, size_t bits) 86{ 87 size_t n; 88 unsigned int bitoff = c->bitoff, 89 bitrem = bitoff % 8, inpgap = (8 - (unsigned int)bits % 8) & 7; 90 const unsigned char *inp = _inp; |
92 | 91 |
93 /* This 256-bit increment procedure relies on the size_t 94 * being natural size of CPU register, so that we don't 95 * have to mask the value in order to detect overflows. */ 96 c->bitlen[0] += bits; 97 if (c->bitlen[0] < bits) /* overflow */ 98 { 99 n = 1; 100 do { c->bitlen[n]++; 101 } while(c->bitlen[n]==0 102 && ++n<(WHIRLPOOL_COUNTER/sizeof(size_t))); 103 } 104 | 92 /* 93 * This 256-bit increment procedure relies on the size_t being natural 94 * size of CPU register, so that we don't have to mask the value in order 95 * to detect overflows. 96 */ 97 c->bitlen[0] += bits; 98 if (c->bitlen[0] < bits) { /* overflow */ 99 n = 1; 100 do { 101 c->bitlen[n]++; 102 } while (c->bitlen[n] == 0 103 && ++n < (WHIRLPOOL_COUNTER / sizeof(size_t))); 104 } |
105#ifndef OPENSSL_SMALL_FOOTPRINT | 105#ifndef OPENSSL_SMALL_FOOTPRINT |
106 reconsider: 107 if (inpgap==0 && bitrem==0) /* byte-oriented loop */ 108 { 109 while (bits) 110 { 111 if (bitoff==0 && (n=bits/WHIRLPOOL_BBLOCK)) 112 { 113 whirlpool_block(c,inp,n); 114 inp += n*WHIRLPOOL_BBLOCK/8; 115 bits %= WHIRLPOOL_BBLOCK; 116 } 117 else 118 { 119 unsigned int byteoff = bitoff/8; | 106 reconsider: 107 if (inpgap == 0 && bitrem == 0) { /* byte-oriented loop */ 108 while (bits) { 109 if (bitoff == 0 && (n = bits / WHIRLPOOL_BBLOCK)) { 110 whirlpool_block(c, inp, n); 111 inp += n * WHIRLPOOL_BBLOCK / 8; 112 bits %= WHIRLPOOL_BBLOCK; 113 } else { 114 unsigned int byteoff = bitoff / 8; |
120 | 115 |
121 bitrem = WHIRLPOOL_BBLOCK - bitoff;/* re-use bitrem */ 122 if (bits >= bitrem) 123 { 124 bits -= bitrem; 125 bitrem /= 8; 126 memcpy(c->data+byteoff,inp,bitrem); 127 inp += bitrem; 128 whirlpool_block(c,c->data,1); 129 bitoff = 0; 130 } 131 else 132 { 133 memcpy(c->data+byteoff,inp,bits/8); 134 bitoff += (unsigned int)bits; 135 bits = 0; 136 } 137 c->bitoff = bitoff; 138 } 139 } 140 } 141 else /* bit-oriented loop */ | 116 bitrem = WHIRLPOOL_BBLOCK - bitoff; /* re-use bitrem */ 117 if (bits >= bitrem) { 118 bits -= bitrem; 119 bitrem /= 8; 120 memcpy(c->data + byteoff, inp, bitrem); 121 inp += bitrem; 122 whirlpool_block(c, c->data, 1); 123 bitoff = 0; 124 } else { 125 memcpy(c->data + byteoff, inp, bits / 8); 126 bitoff += (unsigned int)bits; 127 bits = 0; 128 } 129 c->bitoff = bitoff; 130 } 131 } 132 } else /* bit-oriented loop */ |
142#endif | 133#endif |
143 { 144 /* 145 inp 146 | 147 +-------+-------+------- 148 ||||||||||||||||||||| 149 +-------+-------+------- 150 +-------+-------+-------+-------+------- 151 |||||||||||||| c->data 152 +-------+-------+-------+-------+------- 153 | 154 c->bitoff/8 155 */ 156 while (bits) 157 { 158 unsigned int byteoff = bitoff/8; 159 unsigned char b; | 134 { 135 /*- 136 inp 137 | 138 +-------+-------+------- 139 ||||||||||||||||||||| 140 +-------+-------+------- 141 +-------+-------+-------+-------+------- 142 |||||||||||||| c->data 143 +-------+-------+-------+-------+------- 144 | 145 c->bitoff/8 146 */ 147 while (bits) { 148 unsigned int byteoff = bitoff / 8; 149 unsigned char b; |
160 161#ifndef OPENSSL_SMALL_FOOTPRINT | 150 151#ifndef OPENSSL_SMALL_FOOTPRINT |
162 if (bitrem==inpgap) 163 { 164 c->data[byteoff++] |= inp[0] & (0xff>>inpgap); 165 inpgap = 8-inpgap; 166 bitoff += inpgap; bitrem = 0; /* bitoff%8 */ 167 bits -= inpgap; inpgap = 0; /* bits%8 */ 168 inp++; 169 if (bitoff==WHIRLPOOL_BBLOCK) 170 { 171 whirlpool_block(c,c->data,1); 172 bitoff = 0; 173 } 174 c->bitoff = bitoff; 175 goto reconsider; 176 } 177 else | 152 if (bitrem == inpgap) { 153 c->data[byteoff++] |= inp[0] & (0xff >> inpgap); 154 inpgap = 8 - inpgap; 155 bitoff += inpgap; 156 bitrem = 0; /* bitoff%8 */ 157 bits -= inpgap; 158 inpgap = 0; /* bits%8 */ 159 inp++; 160 if (bitoff == WHIRLPOOL_BBLOCK) { 161 whirlpool_block(c, c->data, 1); 162 bitoff = 0; 163 } 164 c->bitoff = bitoff; 165 goto reconsider; 166 } else |
178#endif | 167#endif |
179 if (bits>=8) 180 { 181 b = ((inp[0]<<inpgap) | (inp[1]>>(8-inpgap))); 182 b &= 0xff; 183 if (bitrem) c->data[byteoff++] |= b>>bitrem; 184 else c->data[byteoff++] = b; 185 bitoff += 8; 186 bits -= 8; 187 inp++; 188 if (bitoff>=WHIRLPOOL_BBLOCK) 189 { 190 whirlpool_block(c,c->data,1); 191 byteoff = 0; 192 bitoff %= WHIRLPOOL_BBLOCK; 193 } 194 if (bitrem) c->data[byteoff] = b<<(8-bitrem); 195 } 196 else /* remaining less than 8 bits */ 197 { 198 b = (inp[0]<<inpgap)&0xff; 199 if (bitrem) c->data[byteoff++] |= b>>bitrem; 200 else c->data[byteoff++] = b; 201 bitoff += (unsigned int)bits; 202 if (bitoff==WHIRLPOOL_BBLOCK) 203 { 204 whirlpool_block(c,c->data,1); 205 byteoff = 0; 206 bitoff %= WHIRLPOOL_BBLOCK; 207 } 208 if (bitrem) c->data[byteoff] = b<<(8-bitrem); 209 bits = 0; 210 } 211 c->bitoff = bitoff; 212 } 213 } 214 } | 168 if (bits >= 8) { 169 b = ((inp[0] << inpgap) | (inp[1] >> (8 - inpgap))); 170 b &= 0xff; 171 if (bitrem) 172 c->data[byteoff++] |= b >> bitrem; 173 else 174 c->data[byteoff++] = b; 175 bitoff += 8; 176 bits -= 8; 177 inp++; 178 if (bitoff >= WHIRLPOOL_BBLOCK) { 179 whirlpool_block(c, c->data, 1); 180 byteoff = 0; 181 bitoff %= WHIRLPOOL_BBLOCK; 182 } 183 if (bitrem) 184 c->data[byteoff] = b << (8 - bitrem); 185 } else { /* remaining less than 8 bits */ |
215 | 186 |
216int WHIRLPOOL_Final (unsigned char *md,WHIRLPOOL_CTX *c) 217 { 218 unsigned int bitoff = c->bitoff, 219 byteoff = bitoff/8; 220 size_t i,j,v; 221 unsigned char *p; | 187 b = (inp[0] << inpgap) & 0xff; 188 if (bitrem) 189 c->data[byteoff++] |= b >> bitrem; 190 else 191 c->data[byteoff++] = b; 192 bitoff += (unsigned int)bits; 193 if (bitoff == WHIRLPOOL_BBLOCK) { 194 whirlpool_block(c, c->data, 1); 195 byteoff = 0; 196 bitoff %= WHIRLPOOL_BBLOCK; 197 } 198 if (bitrem) 199 c->data[byteoff] = b << (8 - bitrem); 200 bits = 0; 201 } 202 c->bitoff = bitoff; 203 } 204 } 205} |
222 | 206 |
223 bitoff %= 8; 224 if (bitoff) c->data[byteoff] |= 0x80>>bitoff; 225 else c->data[byteoff] = 0x80; 226 byteoff++; | 207int WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c) 208{ 209 unsigned int bitoff = c->bitoff, byteoff = bitoff / 8; 210 size_t i, j, v; 211 unsigned char *p; |
227 | 212 |
228 /* pad with zeros */ 229 if (byteoff > (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)) 230 { 231 if (byteoff<WHIRLPOOL_BBLOCK/8) 232 memset(&c->data[byteoff],0,WHIRLPOOL_BBLOCK/8-byteoff); 233 whirlpool_block(c,c->data,1); 234 byteoff = 0; 235 } 236 if (byteoff < (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)) 237 memset(&c->data[byteoff],0, 238 (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)-byteoff); 239 /* smash 256-bit c->bitlen in big-endian order */ 240 p = &c->data[WHIRLPOOL_BBLOCK/8-1]; /* last byte in c->data */ 241 for(i=0;i<WHIRLPOOL_COUNTER/sizeof(size_t);i++) 242 for(v=c->bitlen[i],j=0;j<sizeof(size_t);j++,v>>=8) 243 *p-- = (unsigned char)(v&0xff); | 213 bitoff %= 8; 214 if (bitoff) 215 c->data[byteoff] |= 0x80 >> bitoff; 216 else 217 c->data[byteoff] = 0x80; 218 byteoff++; |
244 | 219 |
245 whirlpool_block(c,c->data,1); | 220 /* pad with zeros */ 221 if (byteoff > (WHIRLPOOL_BBLOCK / 8 - WHIRLPOOL_COUNTER)) { 222 if (byteoff < WHIRLPOOL_BBLOCK / 8) 223 memset(&c->data[byteoff], 0, WHIRLPOOL_BBLOCK / 8 - byteoff); 224 whirlpool_block(c, c->data, 1); 225 byteoff = 0; 226 } 227 if (byteoff < (WHIRLPOOL_BBLOCK / 8 - WHIRLPOOL_COUNTER)) 228 memset(&c->data[byteoff], 0, 229 (WHIRLPOOL_BBLOCK / 8 - WHIRLPOOL_COUNTER) - byteoff); 230 /* smash 256-bit c->bitlen in big-endian order */ 231 p = &c->data[WHIRLPOOL_BBLOCK / 8 - 1]; /* last byte in c->data */ 232 for (i = 0; i < WHIRLPOOL_COUNTER / sizeof(size_t); i++) 233 for (v = c->bitlen[i], j = 0; j < sizeof(size_t); j++, v >>= 8) 234 *p-- = (unsigned char)(v & 0xff); |
246 | 235 |
247 if (md) { 248 memcpy(md,c->H.c,WHIRLPOOL_DIGEST_LENGTH); 249 memset(c,0,sizeof(*c)); 250 return(1); 251 } 252 return(0); 253 } | 236 whirlpool_block(c, c->data, 1); |
254 | 237 |
255unsigned char *WHIRLPOOL(const void *inp, size_t bytes,unsigned char *md) 256 { 257 WHIRLPOOL_CTX ctx; 258 static unsigned char m[WHIRLPOOL_DIGEST_LENGTH]; | 238 if (md) { 239 memcpy(md, c->H.c, WHIRLPOOL_DIGEST_LENGTH); 240 memset(c, 0, sizeof(*c)); 241 return (1); 242 } 243 return (0); 244} |
259 | 245 |
260 if (md == NULL) md=m; 261 WHIRLPOOL_Init(&ctx); 262 WHIRLPOOL_Update(&ctx,inp,bytes); 263 WHIRLPOOL_Final(md,&ctx); 264 return(md); 265 } | 246unsigned char *WHIRLPOOL(const void *inp, size_t bytes, unsigned char *md) 247{ 248 WHIRLPOOL_CTX ctx; 249 static unsigned char m[WHIRLPOOL_DIGEST_LENGTH]; 250 251 if (md == NULL) 252 md = m; 253 WHIRLPOOL_Init(&ctx); 254 WHIRLPOOL_Update(&ctx, inp, bytes); 255 WHIRLPOOL_Final(md, &ctx); 256 return (md); 257} |