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