diff options
Diffstat (limited to 'src/lib/libcrypto/whrlpool/wp_dgst.c')
-rw-r--r-- | src/lib/libcrypto/whrlpool/wp_dgst.c | 264 |
1 files changed, 264 insertions, 0 deletions
diff --git a/src/lib/libcrypto/whrlpool/wp_dgst.c b/src/lib/libcrypto/whrlpool/wp_dgst.c new file mode 100644 index 0000000000..ee5c5c1bf3 --- /dev/null +++ b/src/lib/libcrypto/whrlpool/wp_dgst.c | |||
@@ -0,0 +1,264 @@ | |||
1 | /** | ||
2 | * The Whirlpool hashing function. | ||
3 | * | ||
4 | * <P> | ||
5 | * <b>References</b> | ||
6 | * | ||
7 | * <P> | ||
8 | * The Whirlpool algorithm was developed by | ||
9 | * <a href="mailto:pbarreto@scopus.com.br">Paulo S. L. M. Barreto</a> and | ||
10 | * <a href="mailto:vincent.rijmen@cryptomathic.com">Vincent Rijmen</a>. | ||
11 | * | ||
12 | * See | ||
13 | * P.S.L.M. Barreto, V. Rijmen, | ||
14 | * ``The Whirlpool hashing function,'' | ||
15 | * NESSIE submission, 2000 (tweaked version, 2001), | ||
16 | * <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip> | ||
17 | * | ||
18 | * Based on "@version 3.0 (2003.03.12)" by Paulo S.L.M. Barreto and | ||
19 | * Vincent Rijmen. Lookup "reference implementations" on | ||
20 | * <http://planeta.terra.com.br/informatica/paulobarreto/> | ||
21 | * | ||
22 | * ============================================================================= | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS | ||
25 | * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
26 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE | ||
28 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | ||
29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | ||
30 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR | ||
31 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
32 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE | ||
33 | * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | ||
34 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
35 | * | ||
36 | */ | ||
37 | |||
38 | /* | ||
39 | * OpenSSL-specific implementation notes. | ||
40 | * | ||
41 | * WHIRLPOOL_Update as well as one-stroke WHIRLPOOL both expect | ||
42 | * number of *bytes* as input length argument. Bit-oriented routine | ||
43 | * as specified by authors is called WHIRLPOOL_BitUpdate[!] and | ||
44 | * does not have one-stroke counterpart. | ||
45 | * | ||
46 | * WHIRLPOOL_BitUpdate implements byte-oriented loop, essentially | ||
47 | * to serve WHIRLPOOL_Update. This is done for performance. | ||
48 | * | ||
49 | * Unlike authors' reference implementation, block processing | ||
50 | * routine whirlpool_block is designed to operate on multi-block | ||
51 | * input. This is done for perfomance. | ||
52 | */ | ||
53 | |||
54 | #include "wp_locl.h" | ||
55 | #include <string.h> | ||
56 | |||
57 | int WHIRLPOOL_Init (WHIRLPOOL_CTX *c) | ||
58 | { | ||
59 | memset (c,0,sizeof(*c)); | ||
60 | return(1); | ||
61 | } | ||
62 | |||
63 | int WHIRLPOOL_Update (WHIRLPOOL_CTX *c,const void *_inp,size_t bytes) | ||
64 | { | ||
65 | /* Well, largest suitable chunk size actually is | ||
66 | * (1<<(sizeof(size_t)*8-3))-64, but below number | ||
67 | * is large enough for not to care about excessive | ||
68 | * calls to WHIRLPOOL_BitUpdate... */ | ||
69 | size_t chunk = ((size_t)1)<<(sizeof(size_t)*8-4); | ||
70 | const unsigned char *inp = _inp; | ||
71 | |||
72 | while (bytes>=chunk) | ||
73 | { | ||
74 | WHIRLPOOL_BitUpdate(c,inp,chunk*8); | ||
75 | bytes -= chunk; | ||
76 | inp += chunk; | ||
77 | } | ||
78 | if (bytes) | ||
79 | WHIRLPOOL_BitUpdate(c,inp,bytes*8); | ||
80 | |||
81 | return(1); | ||
82 | } | ||
83 | |||
84 | void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,const void *_inp,size_t bits) | ||
85 | { | ||
86 | size_t n; | ||
87 | unsigned int bitoff = c->bitoff, | ||
88 | bitrem = bitoff%8, | ||
89 | inpgap = (8-(unsigned int)bits%8)&7; | ||
90 | const unsigned char *inp=_inp; | ||
91 | |||
92 | /* This 256-bit increment procedure relies on the size_t | ||
93 | * being natural size of CPU register, so that we don't | ||
94 | * have to mask the value in order to detect overflows. */ | ||
95 | c->bitlen[0] += bits; | ||
96 | if (c->bitlen[0] < bits) /* overflow */ | ||
97 | { | ||
98 | n = 1; | ||
99 | do { c->bitlen[n]++; | ||
100 | } while(c->bitlen[n]==0 | ||
101 | && ++n<(WHIRLPOOL_COUNTER/sizeof(size_t))); | ||
102 | } | ||
103 | |||
104 | #ifndef OPENSSL_SMALL_FOOTPRINT | ||
105 | reconsider: | ||
106 | if (inpgap==0 && bitrem==0) /* byte-oriented loop */ | ||
107 | { | ||
108 | while (bits) | ||
109 | { | ||
110 | if (bitoff==0 && (n=bits/WHIRLPOOL_BBLOCK)) | ||
111 | { | ||
112 | whirlpool_block(c,inp,n); | ||
113 | inp += n*WHIRLPOOL_BBLOCK/8; | ||
114 | bits %= WHIRLPOOL_BBLOCK; | ||
115 | } | ||
116 | else | ||
117 | { | ||
118 | unsigned int byteoff = bitoff/8; | ||
119 | |||
120 | bitrem = WHIRLPOOL_BBLOCK - bitoff;/* re-use bitrem */ | ||
121 | if (bits >= bitrem) | ||
122 | { | ||
123 | bits -= bitrem; | ||
124 | bitrem /= 8; | ||
125 | memcpy(c->data+byteoff,inp,bitrem); | ||
126 | inp += bitrem; | ||
127 | whirlpool_block(c,c->data,1); | ||
128 | bitoff = 0; | ||
129 | } | ||
130 | else | ||
131 | { | ||
132 | memcpy(c->data+byteoff,inp,bits/8); | ||
133 | bitoff += (unsigned int)bits; | ||
134 | bits = 0; | ||
135 | } | ||
136 | c->bitoff = bitoff; | ||
137 | } | ||
138 | } | ||
139 | } | ||
140 | else /* bit-oriented loop */ | ||
141 | #endif | ||
142 | { | ||
143 | /* | ||
144 | inp | ||
145 | | | ||
146 | +-------+-------+------- | ||
147 | ||||||||||||||||||||| | ||
148 | +-------+-------+------- | ||
149 | +-------+-------+-------+-------+------- | ||
150 | |||||||||||||| c->data | ||
151 | +-------+-------+-------+-------+------- | ||
152 | | | ||
153 | c->bitoff/8 | ||
154 | */ | ||
155 | while (bits) | ||
156 | { | ||
157 | unsigned int byteoff = bitoff/8; | ||
158 | unsigned char b; | ||
159 | |||
160 | #ifndef OPENSSL_SMALL_FOOTPRINT | ||
161 | if (bitrem==inpgap) | ||
162 | { | ||
163 | c->data[byteoff++] |= inp[0] & (0xff>>inpgap); | ||
164 | inpgap = 8-inpgap; | ||
165 | bitoff += inpgap; bitrem = 0; /* bitoff%8 */ | ||
166 | bits -= inpgap; inpgap = 0; /* bits%8 */ | ||
167 | inp++; | ||
168 | if (bitoff==WHIRLPOOL_BBLOCK) | ||
169 | { | ||
170 | whirlpool_block(c,c->data,1); | ||
171 | bitoff = 0; | ||
172 | } | ||
173 | c->bitoff = bitoff; | ||
174 | goto reconsider; | ||
175 | } | ||
176 | else | ||
177 | #endif | ||
178 | if (bits>=8) | ||
179 | { | ||
180 | b = ((inp[0]<<inpgap) | (inp[1]>>(8-inpgap))); | ||
181 | b &= 0xff; | ||
182 | if (bitrem) c->data[byteoff++] |= b>>bitrem; | ||
183 | else c->data[byteoff++] = b; | ||
184 | bitoff += 8; | ||
185 | bits -= 8; | ||
186 | inp++; | ||
187 | if (bitoff>=WHIRLPOOL_BBLOCK) | ||
188 | { | ||
189 | whirlpool_block(c,c->data,1); | ||
190 | byteoff = 0; | ||
191 | bitoff %= WHIRLPOOL_BBLOCK; | ||
192 | } | ||
193 | if (bitrem) c->data[byteoff] = b<<(8-bitrem); | ||
194 | } | ||
195 | else /* remaining less than 8 bits */ | ||
196 | { | ||
197 | b = (inp[0]<<inpgap)&0xff; | ||
198 | if (bitrem) c->data[byteoff++] |= b>>bitrem; | ||
199 | else c->data[byteoff++] = b; | ||
200 | bitoff += (unsigned int)bits; | ||
201 | if (bitoff==WHIRLPOOL_BBLOCK) | ||
202 | { | ||
203 | whirlpool_block(c,c->data,1); | ||
204 | byteoff = 0; | ||
205 | bitoff %= WHIRLPOOL_BBLOCK; | ||
206 | } | ||
207 | if (bitrem) c->data[byteoff] = b<<(8-bitrem); | ||
208 | bits = 0; | ||
209 | } | ||
210 | c->bitoff = bitoff; | ||
211 | } | ||
212 | } | ||
213 | } | ||
214 | |||
215 | int WHIRLPOOL_Final (unsigned char *md,WHIRLPOOL_CTX *c) | ||
216 | { | ||
217 | unsigned int bitoff = c->bitoff, | ||
218 | byteoff = bitoff/8; | ||
219 | size_t i,j,v; | ||
220 | unsigned char *p; | ||
221 | |||
222 | bitoff %= 8; | ||
223 | if (bitoff) c->data[byteoff] |= 0x80>>bitoff; | ||
224 | else c->data[byteoff] = 0x80; | ||
225 | byteoff++; | ||
226 | |||
227 | /* pad with zeros */ | ||
228 | if (byteoff > (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)) | ||
229 | { | ||
230 | if (byteoff<WHIRLPOOL_BBLOCK/8) | ||
231 | memset(&c->data[byteoff],0,WHIRLPOOL_BBLOCK/8-byteoff); | ||
232 | whirlpool_block(c,c->data,1); | ||
233 | byteoff = 0; | ||
234 | } | ||
235 | if (byteoff < (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)) | ||
236 | memset(&c->data[byteoff],0, | ||
237 | (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)-byteoff); | ||
238 | /* smash 256-bit c->bitlen in big-endian order */ | ||
239 | p = &c->data[WHIRLPOOL_BBLOCK/8-1]; /* last byte in c->data */ | ||
240 | for(i=0;i<WHIRLPOOL_COUNTER/sizeof(size_t);i++) | ||
241 | for(v=c->bitlen[i],j=0;j<sizeof(size_t);j++,v>>=8) | ||
242 | *p-- = (unsigned char)(v&0xff); | ||
243 | |||
244 | whirlpool_block(c,c->data,1); | ||
245 | |||
246 | if (md) { | ||
247 | memcpy(md,c->H.c,WHIRLPOOL_DIGEST_LENGTH); | ||
248 | memset(c,0,sizeof(*c)); | ||
249 | return(1); | ||
250 | } | ||
251 | return(0); | ||
252 | } | ||
253 | |||
254 | unsigned char *WHIRLPOOL(const void *inp, size_t bytes,unsigned char *md) | ||
255 | { | ||
256 | WHIRLPOOL_CTX ctx; | ||
257 | static unsigned char m[WHIRLPOOL_DIGEST_LENGTH]; | ||
258 | |||
259 | if (md == NULL) md=m; | ||
260 | WHIRLPOOL_Init(&ctx); | ||
261 | WHIRLPOOL_Update(&ctx,inp,bytes); | ||
262 | WHIRLPOOL_Final(md,&ctx); | ||
263 | return(md); | ||
264 | } | ||