Coverage Report

Created: 2024-07-27 06:39

/src/openssl/include/crypto/md32_common.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1999-2022 The OpenSSL Project Authors. All Rights Reserved.
3
 *
4
 * Licensed under the Apache License 2.0 (the "License").  You may not use
5
 * this file except in compliance with the License.  You can obtain a copy
6
 * in the file LICENSE in the source distribution or at
7
 * https://www.openssl.org/source/license.html
8
 */
9
10
/*-
11
 * This is a generic 32 bit "collector" for message digest algorithms.
12
 * Whenever needed it collects input character stream into chunks of
13
 * 32 bit values and invokes a block function that performs actual hash
14
 * calculations.
15
 *
16
 * Porting guide.
17
 *
18
 * Obligatory macros:
19
 *
20
 * DATA_ORDER_IS_BIG_ENDIAN or DATA_ORDER_IS_LITTLE_ENDIAN
21
 *      this macro defines byte order of input stream.
22
 * HASH_CBLOCK
23
 *      size of a unit chunk HASH_BLOCK operates on.
24
 * HASH_LONG
25
 *      has to be at least 32 bit wide.
26
 * HASH_CTX
27
 *      context structure that at least contains following
28
 *      members:
29
 *              typedef struct {
30
 *                      ...
31
 *                      HASH_LONG       Nl,Nh;
32
 *                      either {
33
 *                      HASH_LONG       data[HASH_LBLOCK];
34
 *                      unsigned char   data[HASH_CBLOCK];
35
 *                      };
36
 *                      unsigned int    num;
37
 *                      ...
38
 *                      } HASH_CTX;
39
 *      data[] vector is expected to be zeroed upon first call to
40
 *      HASH_UPDATE.
41
 * HASH_UPDATE
42
 *      name of "Update" function, implemented here.
43
 * HASH_TRANSFORM
44
 *      name of "Transform" function, implemented here.
45
 * HASH_FINAL
46
 *      name of "Final" function, implemented here.
47
 * HASH_BLOCK_DATA_ORDER
48
 *      name of "block" function capable of treating *unaligned* input
49
 *      message in original (data) byte order, implemented externally.
50
 * HASH_MAKE_STRING
51
 *      macro converting context variables to an ASCII hash string.
52
 *
53
 * MD5 example:
54
 *
55
 *      #define DATA_ORDER_IS_LITTLE_ENDIAN
56
 *
57
 *      #define HASH_LONG               MD5_LONG
58
 *      #define HASH_CTX                MD5_CTX
59
 *      #define HASH_CBLOCK             MD5_CBLOCK
60
 *      #define HASH_UPDATE             MD5_Update
61
 *      #define HASH_TRANSFORM          MD5_Transform
62
 *      #define HASH_FINAL              MD5_Final
63
 *      #define HASH_BLOCK_DATA_ORDER   md5_block_data_order
64
 */
65
66
#ifndef OSSL_CRYPTO_MD32_COMMON_H
67
# define OSSL_CRYPTO_MD32_COMMON_H
68
# pragma once
69
70
# include <openssl/crypto.h>
71
72
# if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
73
#  error "DATA_ORDER must be defined!"
74
# endif
75
76
# ifndef HASH_CBLOCK
77
#  error "HASH_CBLOCK must be defined!"
78
# endif
79
# ifndef HASH_LONG
80
#  error "HASH_LONG must be defined!"
81
# endif
82
# ifndef HASH_CTX
83
#  error "HASH_CTX must be defined!"
84
# endif
85
86
# ifndef HASH_UPDATE
87
#  error "HASH_UPDATE must be defined!"
88
# endif
89
# ifndef HASH_TRANSFORM
90
#  error "HASH_TRANSFORM must be defined!"
91
# endif
92
# ifndef HASH_FINAL
93
#  error "HASH_FINAL must be defined!"
94
# endif
95
96
# ifndef HASH_BLOCK_DATA_ORDER
97
#  error "HASH_BLOCK_DATA_ORDER must be defined!"
98
# endif
99
100
475M
# define ROTATE(a,n)     (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
101
102
#ifndef PEDANTIC
103
# if defined(__GNUC__) && __GNUC__>=2 && \
104
     !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
105
#  if defined(__riscv_zbb) || defined(__riscv_zbkb)
106
#   if __riscv_xlen == 64
107
#   undef ROTATE
108
#   define ROTATE(x, n) ({ MD32_REG_T ret;            \
109
                       asm ("roriw %0, %1, %2"        \
110
                       : "=r"(ret)                    \
111
                       : "r"(x), "i"(32 - (n))); ret;})
112
#   endif
113
#   if __riscv_xlen == 32
114
#   undef ROTATE
115
#   define ROTATE(x, n) ({ MD32_REG_T ret;            \
116
                       asm ("rori %0, %1, %2"         \
117
                       : "=r"(ret)                    \
118
                       : "r"(x), "i"(32 - (n))); ret;})
119
#   endif
120
#  endif
121
# endif
122
#endif
123
124
# if defined(DATA_ORDER_IS_BIG_ENDIAN)
125
126
1.23M
#  define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))<<24),          \
127
1.23M
                         l|=(((unsigned long)(*((c)++)))<<16),          \
128
1.23M
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
129
1.23M
                         l|=(((unsigned long)(*((c)++)))    )           )
130
12.8M
#  define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)>>24)&0xff),      \
131
12.8M
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
132
12.8M
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
133
12.8M
                         *((c)++)=(unsigned char)(((l)    )&0xff),      \
134
12.8M
                         l)
135
136
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
137
138
21.7M
#  define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))    ),          \
139
21.7M
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
140
21.7M
                         l|=(((unsigned long)(*((c)++)))<<16),          \
141
21.7M
                         l|=(((unsigned long)(*((c)++)))<<24)           )
142
11.0M
#  define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)    )&0xff),      \
143
11.0M
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
144
11.0M
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
145
11.0M
                         *((c)++)=(unsigned char)(((l)>>24)&0xff),      \
146
11.0M
                         l)
147
148
# endif
149
150
/*
151
 * Time for some action :-)
152
 */
153
154
int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
155
4.57M
{
156
4.57M
    const unsigned char *data = data_;
157
4.57M
    unsigned char *p;
158
4.57M
    HASH_LONG l;
159
4.57M
    size_t n;
160
161
4.57M
    if (len == 0)
162
0
        return 1;
163
164
4.57M
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
4.57M
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
4.57M
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
4.57M
    c->Nl = l;
170
171
4.57M
    n = c->num;
172
4.57M
    if (n != 0) {
173
757k
        p = (unsigned char *)c->data;
174
175
757k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
236k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
236k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
236k
            n = HASH_CBLOCK - n;
179
236k
            data += n;
180
236k
            len -= n;
181
236k
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
236k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
521k
        } else {
190
521k
            memcpy(p + n, data, len);
191
521k
            c->num += (unsigned int)len;
192
521k
            return 1;
193
521k
        }
194
757k
    }
195
196
4.05M
    n = len / HASH_CBLOCK;
197
4.05M
    if (n > 0) {
198
915k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
915k
        n *= HASH_CBLOCK;
200
915k
        data += n;
201
915k
        len -= n;
202
915k
    }
203
204
4.05M
    if (len != 0) {
205
3.42M
        p = (unsigned char *)c->data;
206
3.42M
        c->num = (unsigned int)len;
207
3.42M
        memcpy(p, data, len);
208
3.42M
    }
209
4.05M
    return 1;
210
4.57M
}
Unexecuted instantiation: MD4_Update
MD5_Update
Line
Count
Source
155
463k
{
156
463k
    const unsigned char *data = data_;
157
463k
    unsigned char *p;
158
463k
    HASH_LONG l;
159
463k
    size_t n;
160
161
463k
    if (len == 0)
162
0
        return 1;
163
164
463k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
463k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
463k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
463k
    c->Nl = l;
170
171
463k
    n = c->num;
172
463k
    if (n != 0) {
173
153k
        p = (unsigned char *)c->data;
174
175
153k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
66.2k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
66.2k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
66.2k
            n = HASH_CBLOCK - n;
179
66.2k
            data += n;
180
66.2k
            len -= n;
181
66.2k
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
66.2k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
87.0k
        } else {
190
87.0k
            memcpy(p + n, data, len);
191
87.0k
            c->num += (unsigned int)len;
192
87.0k
            return 1;
193
87.0k
        }
194
153k
    }
195
196
376k
    n = len / HASH_CBLOCK;
197
376k
    if (n > 0) {
198
41.7k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
41.7k
        n *= HASH_CBLOCK;
200
41.7k
        data += n;
201
41.7k
        len -= n;
202
41.7k
    }
203
204
376k
    if (len != 0) {
205
350k
        p = (unsigned char *)c->data;
206
350k
        c->num = (unsigned int)len;
207
350k
        memcpy(p, data, len);
208
350k
    }
209
376k
    return 1;
210
463k
}
RIPEMD160_Update
Line
Count
Source
155
1.31M
{
156
1.31M
    const unsigned char *data = data_;
157
1.31M
    unsigned char *p;
158
1.31M
    HASH_LONG l;
159
1.31M
    size_t n;
160
161
1.31M
    if (len == 0)
162
0
        return 1;
163
164
1.31M
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
1.31M
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
1.31M
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
1.31M
    c->Nl = l;
170
171
1.31M
    n = c->num;
172
1.31M
    if (n != 0) {
173
253
        p = (unsigned char *)c->data;
174
175
253
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
119
            memcpy(p + n, data, HASH_CBLOCK - n);
177
119
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
119
            n = HASH_CBLOCK - n;
179
119
            data += n;
180
119
            len -= n;
181
119
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
119
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
134
        } else {
190
134
            memcpy(p + n, data, len);
191
134
            c->num += (unsigned int)len;
192
134
            return 1;
193
134
        }
194
253
    }
195
196
1.31M
    n = len / HASH_CBLOCK;
197
1.31M
    if (n > 0) {
198
483
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
483
        n *= HASH_CBLOCK;
200
483
        data += n;
201
483
        len -= n;
202
483
    }
203
204
1.31M
    if (len != 0) {
205
1.31M
        p = (unsigned char *)c->data;
206
1.31M
        c->num = (unsigned int)len;
207
1.31M
        memcpy(p, data, len);
208
1.31M
    }
209
1.31M
    return 1;
210
1.31M
}
SHA1_Update
Line
Count
Source
155
977k
{
156
977k
    const unsigned char *data = data_;
157
977k
    unsigned char *p;
158
977k
    HASH_LONG l;
159
977k
    size_t n;
160
161
977k
    if (len == 0)
162
0
        return 1;
163
164
977k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
977k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
977k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
977k
    c->Nl = l;
170
171
977k
    n = c->num;
172
977k
    if (n != 0) {
173
280k
        p = (unsigned char *)c->data;
174
175
280k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
104k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
104k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
104k
            n = HASH_CBLOCK - n;
179
104k
            data += n;
180
104k
            len -= n;
181
104k
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
104k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
175k
        } else {
190
175k
            memcpy(p + n, data, len);
191
175k
            c->num += (unsigned int)len;
192
175k
            return 1;
193
175k
        }
194
280k
    }
195
196
801k
    n = len / HASH_CBLOCK;
197
801k
    if (n > 0) {
198
271k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
271k
        n *= HASH_CBLOCK;
200
271k
        data += n;
201
271k
        len -= n;
202
271k
    }
203
204
801k
    if (len != 0) {
205
748k
        p = (unsigned char *)c->data;
206
748k
        c->num = (unsigned int)len;
207
748k
        memcpy(p, data, len);
208
748k
    }
209
801k
    return 1;
210
977k
}
SHA256_Update
Line
Count
Source
155
1.81M
{
156
1.81M
    const unsigned char *data = data_;
157
1.81M
    unsigned char *p;
158
1.81M
    HASH_LONG l;
159
1.81M
    size_t n;
160
161
1.81M
    if (len == 0)
162
0
        return 1;
163
164
1.81M
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
1.81M
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
1.81M
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
1.81M
    c->Nl = l;
170
171
1.81M
    n = c->num;
172
1.81M
    if (n != 0) {
173
323k
        p = (unsigned char *)c->data;
174
175
323k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
65.1k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
65.1k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
65.1k
            n = HASH_CBLOCK - n;
179
65.1k
            data += n;
180
65.1k
            len -= n;
181
65.1k
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
65.1k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
258k
        } else {
190
258k
            memcpy(p + n, data, len);
191
258k
            c->num += (unsigned int)len;
192
258k
            return 1;
193
258k
        }
194
323k
    }
195
196
1.56M
    n = len / HASH_CBLOCK;
197
1.56M
    if (n > 0) {
198
600k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
600k
        n *= HASH_CBLOCK;
200
600k
        data += n;
201
600k
        len -= n;
202
600k
    }
203
204
1.56M
    if (len != 0) {
205
1.01M
        p = (unsigned char *)c->data;
206
1.01M
        c->num = (unsigned int)len;
207
1.01M
        memcpy(p, data, len);
208
1.01M
    }
209
1.56M
    return 1;
210
1.81M
}
ossl_sm3_update
Line
Count
Source
155
1.67k
{
156
1.67k
    const unsigned char *data = data_;
157
1.67k
    unsigned char *p;
158
1.67k
    HASH_LONG l;
159
1.67k
    size_t n;
160
161
1.67k
    if (len == 0)
162
0
        return 1;
163
164
1.67k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
1.67k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
1.67k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
1.67k
    c->Nl = l;
170
171
1.67k
    n = c->num;
172
1.67k
    if (n != 0) {
173
241
        p = (unsigned char *)c->data;
174
175
241
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
82
            memcpy(p + n, data, HASH_CBLOCK - n);
177
82
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
82
            n = HASH_CBLOCK - n;
179
82
            data += n;
180
82
            len -= n;
181
82
            c->num = 0;
182
            /*
183
             * We use memset rather than OPENSSL_cleanse() here deliberately.
184
             * Using OPENSSL_cleanse() here could be a performance issue. It
185
             * will get properly cleansed on finalisation so this isn't a
186
             * security problem.
187
             */
188
82
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
159
        } else {
190
159
            memcpy(p + n, data, len);
191
159
            c->num += (unsigned int)len;
192
159
            return 1;
193
159
        }
194
241
    }
195
196
1.51k
    n = len / HASH_CBLOCK;
197
1.51k
    if (n > 0) {
198
790
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
790
        n *= HASH_CBLOCK;
200
790
        data += n;
201
790
        len -= n;
202
790
    }
203
204
1.51k
    if (len != 0) {
205
828
        p = (unsigned char *)c->data;
206
828
        c->num = (unsigned int)len;
207
828
        memcpy(p, data, len);
208
828
    }
209
1.51k
    return 1;
210
1.67k
}
211
212
void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data)
213
195k
{
214
195k
    HASH_BLOCK_DATA_ORDER(c, data, 1);
215
195k
}
Unexecuted instantiation: MD4_Transform
Unexecuted instantiation: MD5_Transform
Unexecuted instantiation: RIPEMD160_Transform
SHA1_Transform
Line
Count
Source
213
156k
{
214
156k
    HASH_BLOCK_DATA_ORDER(c, data, 1);
215
156k
}
SHA256_Transform
Line
Count
Source
213
39.3k
{
214
39.3k
    HASH_BLOCK_DATA_ORDER(c, data, 1);
215
39.3k
}
Unexecuted instantiation: ossl_sm3_transform
216
217
int HASH_FINAL(unsigned char *md, HASH_CTX *c)
218
3.10M
{
219
3.10M
    unsigned char *p = (unsigned char *)c->data;
220
3.10M
    size_t n = c->num;
221
222
3.10M
    p[n] = 0x80;                /* there is always room for one */
223
3.10M
    n++;
224
225
3.10M
    if (n > (HASH_CBLOCK - 8)) {
226
65.7k
        memset(p + n, 0, HASH_CBLOCK - n);
227
65.7k
        n = 0;
228
65.7k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
65.7k
    }
230
3.10M
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
3.10M
    p += HASH_CBLOCK - 8;
233
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
1.49M
    (void)HOST_l2c(c->Nh, p);
235
1.49M
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
1.61M
    (void)HOST_l2c(c->Nl, p);
238
1.61M
    (void)HOST_l2c(c->Nh, p);
239
# endif
240
3.10M
    p -= HASH_CBLOCK;
241
3.10M
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
3.10M
    c->num = 0;
243
3.10M
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
3.10M
    HASH_MAKE_STRING(c, md);
249
822k
# endif
250
251
822k
    return 1;
252
3.10M
}
Unexecuted instantiation: MD4_Final
MD5_Final
Line
Count
Source
218
301k
{
219
301k
    unsigned char *p = (unsigned char *)c->data;
220
301k
    size_t n = c->num;
221
222
301k
    p[n] = 0x80;                /* there is always room for one */
223
301k
    n++;
224
225
301k
    if (n > (HASH_CBLOCK - 8)) {
226
2.98k
        memset(p + n, 0, HASH_CBLOCK - n);
227
2.98k
        n = 0;
228
2.98k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
2.98k
    }
230
301k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
301k
    p += HASH_CBLOCK - 8;
233
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
    (void)HOST_l2c(c->Nh, p);
235
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
301k
    (void)HOST_l2c(c->Nl, p);
238
301k
    (void)HOST_l2c(c->Nh, p);
239
301k
# endif
240
301k
    p -= HASH_CBLOCK;
241
301k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
301k
    c->num = 0;
243
301k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
301k
    HASH_MAKE_STRING(c, md);
249
301k
# endif
250
251
301k
    return 1;
252
301k
}
RIPEMD160_Final
Line
Count
Source
218
1.31M
{
219
1.31M
    unsigned char *p = (unsigned char *)c->data;
220
1.31M
    size_t n = c->num;
221
222
1.31M
    p[n] = 0x80;                /* there is always room for one */
223
1.31M
    n++;
224
225
1.31M
    if (n > (HASH_CBLOCK - 8)) {
226
61
        memset(p + n, 0, HASH_CBLOCK - n);
227
61
        n = 0;
228
61
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
61
    }
230
1.31M
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
1.31M
    p += HASH_CBLOCK - 8;
233
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
    (void)HOST_l2c(c->Nh, p);
235
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
1.31M
    (void)HOST_l2c(c->Nl, p);
238
1.31M
    (void)HOST_l2c(c->Nh, p);
239
1.31M
# endif
240
1.31M
    p -= HASH_CBLOCK;
241
1.31M
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
1.31M
    c->num = 0;
243
1.31M
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
1.31M
    HASH_MAKE_STRING(c, md);
249
1.31M
# endif
250
251
1.31M
    return 1;
252
1.31M
}
SHA1_Final
Line
Count
Source
218
670k
{
219
670k
    unsigned char *p = (unsigned char *)c->data;
220
670k
    size_t n = c->num;
221
222
670k
    p[n] = 0x80;                /* there is always room for one */
223
670k
    n++;
224
225
670k
    if (n > (HASH_CBLOCK - 8)) {
226
60.6k
        memset(p + n, 0, HASH_CBLOCK - n);
227
60.6k
        n = 0;
228
60.6k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
60.6k
    }
230
670k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
670k
    p += HASH_CBLOCK - 8;
233
670k
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
670k
    (void)HOST_l2c(c->Nh, p);
235
670k
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
    (void)HOST_l2c(c->Nl, p);
238
    (void)HOST_l2c(c->Nh, p);
239
# endif
240
670k
    p -= HASH_CBLOCK;
241
670k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
670k
    c->num = 0;
243
670k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
670k
    HASH_MAKE_STRING(c, md);
249
670k
# endif
250
251
670k
    return 1;
252
670k
}
SHA256_Final
Line
Count
Source
218
822k
{
219
822k
    unsigned char *p = (unsigned char *)c->data;
220
822k
    size_t n = c->num;
221
222
822k
    p[n] = 0x80;                /* there is always room for one */
223
822k
    n++;
224
225
822k
    if (n > (HASH_CBLOCK - 8)) {
226
2.02k
        memset(p + n, 0, HASH_CBLOCK - n);
227
2.02k
        n = 0;
228
2.02k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
2.02k
    }
230
822k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
822k
    p += HASH_CBLOCK - 8;
233
822k
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
822k
    (void)HOST_l2c(c->Nh, p);
235
822k
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
    (void)HOST_l2c(c->Nl, p);
238
    (void)HOST_l2c(c->Nh, p);
239
# endif
240
822k
    p -= HASH_CBLOCK;
241
822k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
822k
    c->num = 0;
243
822k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
822k
    HASH_MAKE_STRING(c, md);
249
822k
# endif
250
251
822k
    return 1;
252
822k
}
ossl_sm3_final
Line
Count
Source
218
775
{
219
775
    unsigned char *p = (unsigned char *)c->data;
220
775
    size_t n = c->num;
221
222
775
    p[n] = 0x80;                /* there is always room for one */
223
775
    n++;
224
225
775
    if (n > (HASH_CBLOCK - 8)) {
226
49
        memset(p + n, 0, HASH_CBLOCK - n);
227
49
        n = 0;
228
49
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
49
    }
230
775
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
775
    p += HASH_CBLOCK - 8;
233
775
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
775
    (void)HOST_l2c(c->Nh, p);
235
775
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
    (void)HOST_l2c(c->Nl, p);
238
    (void)HOST_l2c(c->Nh, p);
239
# endif
240
775
    p -= HASH_CBLOCK;
241
775
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
775
    c->num = 0;
243
775
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
775
    HASH_MAKE_STRING(c, md);
249
775
# endif
250
251
775
    return 1;
252
775
}
253
254
# ifndef MD32_REG_T
255
#  if defined(__alpha) || defined(__sparcv9) || defined(__mips)
256
#   define MD32_REG_T long
257
/*
258
 * This comment was originally written for MD5, which is why it
259
 * discusses A-D. But it basically applies to all 32-bit digests,
260
 * which is why it was moved to common header file.
261
 *
262
 * In case you wonder why A-D are declared as long and not
263
 * as MD5_LONG. Doing so results in slight performance
264
 * boost on LP64 architectures. The catch is we don't
265
 * really care if 32 MSBs of a 64-bit register get polluted
266
 * with eventual overflows as we *save* only 32 LSBs in
267
 * *either* case. Now declaring 'em long excuses the compiler
268
 * from keeping 32 MSBs zeroed resulting in 13% performance
269
 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
270
 * Well, to be honest it should say that this *prevents*
271
 * performance degradation.
272
 */
273
#  else
274
/*
275
 * Above is not absolute and there are LP64 compilers that
276
 * generate better code if MD32_REG_T is defined int. The above
277
 * pre-processor condition reflects the circumstances under which
278
 * the conclusion was made and is subject to further extension.
279
 */
280
#   define MD32_REG_T int
281
#  endif
282
# endif
283
284
#endif