Coverage Report

Created: 2023-06-08 06:41

/src/openssl30/include/crypto/md32_common.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1999-2018 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
#include <openssl/crypto.h>
67
68
#if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
69
# error "DATA_ORDER must be defined!"
70
#endif
71
72
#ifndef HASH_CBLOCK
73
# error "HASH_CBLOCK must be defined!"
74
#endif
75
#ifndef HASH_LONG
76
# error "HASH_LONG must be defined!"
77
#endif
78
#ifndef HASH_CTX
79
# error "HASH_CTX must be defined!"
80
#endif
81
82
#ifndef HASH_UPDATE
83
# error "HASH_UPDATE must be defined!"
84
#endif
85
#ifndef HASH_TRANSFORM
86
# error "HASH_TRANSFORM must be defined!"
87
#endif
88
#ifndef HASH_FINAL
89
# error "HASH_FINAL must be defined!"
90
#endif
91
92
#ifndef HASH_BLOCK_DATA_ORDER
93
# error "HASH_BLOCK_DATA_ORDER must be defined!"
94
#endif
95
96
76.5M
#define ROTATE(a,n)     (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
97
98
#if defined(DATA_ORDER_IS_BIG_ENDIAN)
99
100
0
# define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))<<24),          \
101
0
                         l|=(((unsigned long)(*((c)++)))<<16),          \
102
0
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
103
0
                         l|=(((unsigned long)(*((c)++)))    )           )
104
1.01M
# define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)>>24)&0xff),      \
105
1.01M
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
106
1.01M
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
107
1.01M
                         *((c)++)=(unsigned char)(((l)    )&0xff),      \
108
1.01M
                         l)
109
110
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
111
112
3.82M
# define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))    ),          \
113
3.82M
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
114
3.82M
                         l|=(((unsigned long)(*((c)++)))<<16),          \
115
3.82M
                         l|=(((unsigned long)(*((c)++)))<<24)           )
116
1.67M
# define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)    )&0xff),      \
117
1.67M
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
118
1.67M
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
119
1.67M
                         *((c)++)=(unsigned char)(((l)>>24)&0xff),      \
120
1.67M
                         l)
121
122
#endif
123
124
/*
125
 * Time for some action :-)
126
 */
127
128
int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
129
350k
{
130
350k
    const unsigned char *data = data_;
131
350k
    unsigned char *p;
132
350k
    HASH_LONG l;
133
350k
    size_t n;
134
135
350k
    if (len == 0)
136
0
        return 1;
137
138
350k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139
350k
    if (l < c->Nl)              /* overflow */
140
0
        c->Nh++;
141
350k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142
                                       * 16-bit */
143
350k
    c->Nl = l;
144
145
350k
    n = c->num;
146
350k
    if (n != 0) {
147
192
        p = (unsigned char *)c->data;
148
149
192
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150
0
            memcpy(p + n, data, HASH_CBLOCK - n);
151
0
            HASH_BLOCK_DATA_ORDER(c, p, 1);
152
0
            n = HASH_CBLOCK - n;
153
0
            data += n;
154
0
            len -= n;
155
0
            c->num = 0;
156
            /*
157
             * We use memset rather than OPENSSL_cleanse() here deliberately.
158
             * Using OPENSSL_cleanse() here could be a performance issue. It
159
             * will get properly cleansed on finalisation so this isn't a
160
             * security problem.
161
             */
162
0
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163
192
        } else {
164
192
            memcpy(p + n, data, len);
165
192
            c->num += (unsigned int)len;
166
192
            return 1;
167
192
        }
168
192
    }
169
170
350k
    n = len / HASH_CBLOCK;
171
350k
    if (n > 0) {
172
1.78k
        HASH_BLOCK_DATA_ORDER(c, data, n);
173
1.78k
        n *= HASH_CBLOCK;
174
1.78k
        data += n;
175
1.78k
        len -= n;
176
1.78k
    }
177
178
350k
    if (len != 0) {
179
350k
        p = (unsigned char *)c->data;
180
350k
        c->num = (unsigned int)len;
181
350k
        memcpy(p, data, len);
182
350k
    }
183
350k
    return 1;
184
350k
}
Unexecuted instantiation: MD4_Update
MD5_Update
Line
Count
Source
129
60
{
130
60
    const unsigned char *data = data_;
131
60
    unsigned char *p;
132
60
    HASH_LONG l;
133
60
    size_t n;
134
135
60
    if (len == 0)
136
0
        return 1;
137
138
60
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139
60
    if (l < c->Nl)              /* overflow */
140
0
        c->Nh++;
141
60
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142
                                       * 16-bit */
143
60
    c->Nl = l;
144
145
60
    n = c->num;
146
60
    if (n != 0) {
147
0
        p = (unsigned char *)c->data;
148
149
0
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150
0
            memcpy(p + n, data, HASH_CBLOCK - n);
151
0
            HASH_BLOCK_DATA_ORDER(c, p, 1);
152
0
            n = HASH_CBLOCK - n;
153
0
            data += n;
154
0
            len -= n;
155
0
            c->num = 0;
156
            /*
157
             * We use memset rather than OPENSSL_cleanse() here deliberately.
158
             * Using OPENSSL_cleanse() here could be a performance issue. It
159
             * will get properly cleansed on finalisation so this isn't a
160
             * security problem.
161
             */
162
0
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163
0
        } else {
164
0
            memcpy(p + n, data, len);
165
0
            c->num += (unsigned int)len;
166
0
            return 1;
167
0
        }
168
0
    }
169
170
60
    n = len / HASH_CBLOCK;
171
60
    if (n > 0) {
172
47
        HASH_BLOCK_DATA_ORDER(c, data, n);
173
47
        n *= HASH_CBLOCK;
174
47
        data += n;
175
47
        len -= n;
176
47
    }
177
178
60
    if (len != 0) {
179
33
        p = (unsigned char *)c->data;
180
33
        c->num = (unsigned int)len;
181
33
        memcpy(p, data, len);
182
33
    }
183
60
    return 1;
184
60
}
RIPEMD160_Update
Line
Count
Source
129
239k
{
130
239k
    const unsigned char *data = data_;
131
239k
    unsigned char *p;
132
239k
    HASH_LONG l;
133
239k
    size_t n;
134
135
239k
    if (len == 0)
136
0
        return 1;
137
138
239k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139
239k
    if (l < c->Nl)              /* overflow */
140
0
        c->Nh++;
141
239k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142
                                       * 16-bit */
143
239k
    c->Nl = l;
144
145
239k
    n = c->num;
146
239k
    if (n != 0) {
147
0
        p = (unsigned char *)c->data;
148
149
0
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150
0
            memcpy(p + n, data, HASH_CBLOCK - n);
151
0
            HASH_BLOCK_DATA_ORDER(c, p, 1);
152
0
            n = HASH_CBLOCK - n;
153
0
            data += n;
154
0
            len -= n;
155
0
            c->num = 0;
156
            /*
157
             * We use memset rather than OPENSSL_cleanse() here deliberately.
158
             * Using OPENSSL_cleanse() here could be a performance issue. It
159
             * will get properly cleansed on finalisation so this isn't a
160
             * security problem.
161
             */
162
0
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163
0
        } else {
164
0
            memcpy(p + n, data, len);
165
0
            c->num += (unsigned int)len;
166
0
            return 1;
167
0
        }
168
0
    }
169
170
239k
    n = len / HASH_CBLOCK;
171
239k
    if (n > 0) {
172
0
        HASH_BLOCK_DATA_ORDER(c, data, n);
173
0
        n *= HASH_CBLOCK;
174
0
        data += n;
175
0
        len -= n;
176
0
    }
177
178
239k
    if (len != 0) {
179
239k
        p = (unsigned char *)c->data;
180
239k
        c->num = (unsigned int)len;
181
239k
        memcpy(p, data, len);
182
239k
    }
183
239k
    return 1;
184
239k
}
SHA1_Update
Line
Count
Source
129
17.5k
{
130
17.5k
    const unsigned char *data = data_;
131
17.5k
    unsigned char *p;
132
17.5k
    HASH_LONG l;
133
17.5k
    size_t n;
134
135
17.5k
    if (len == 0)
136
0
        return 1;
137
138
17.5k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139
17.5k
    if (l < c->Nl)              /* overflow */
140
0
        c->Nh++;
141
17.5k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142
                                       * 16-bit */
143
17.5k
    c->Nl = l;
144
145
17.5k
    n = c->num;
146
17.5k
    if (n != 0) {
147
192
        p = (unsigned char *)c->data;
148
149
192
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150
0
            memcpy(p + n, data, HASH_CBLOCK - n);
151
0
            HASH_BLOCK_DATA_ORDER(c, p, 1);
152
0
            n = HASH_CBLOCK - n;
153
0
            data += n;
154
0
            len -= n;
155
0
            c->num = 0;
156
            /*
157
             * We use memset rather than OPENSSL_cleanse() here deliberately.
158
             * Using OPENSSL_cleanse() here could be a performance issue. It
159
             * will get properly cleansed on finalisation so this isn't a
160
             * security problem.
161
             */
162
0
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163
192
        } else {
164
192
            memcpy(p + n, data, len);
165
192
            c->num += (unsigned int)len;
166
192
            return 1;
167
192
        }
168
192
    }
169
170
17.3k
    n = len / HASH_CBLOCK;
171
17.3k
    if (n > 0) {
172
1.63k
        HASH_BLOCK_DATA_ORDER(c, data, n);
173
1.63k
        n *= HASH_CBLOCK;
174
1.63k
        data += n;
175
1.63k
        len -= n;
176
1.63k
    }
177
178
17.3k
    if (len != 0) {
179
17.2k
        p = (unsigned char *)c->data;
180
17.2k
        c->num = (unsigned int)len;
181
17.2k
        memcpy(p, data, len);
182
17.2k
    }
183
17.3k
    return 1;
184
17.5k
}
SHA256_Update
Line
Count
Source
129
93.6k
{
130
93.6k
    const unsigned char *data = data_;
131
93.6k
    unsigned char *p;
132
93.6k
    HASH_LONG l;
133
93.6k
    size_t n;
134
135
93.6k
    if (len == 0)
136
0
        return 1;
137
138
93.6k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139
93.6k
    if (l < c->Nl)              /* overflow */
140
0
        c->Nh++;
141
93.6k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142
                                       * 16-bit */
143
93.6k
    c->Nl = l;
144
145
93.6k
    n = c->num;
146
93.6k
    if (n != 0) {
147
0
        p = (unsigned char *)c->data;
148
149
0
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150
0
            memcpy(p + n, data, HASH_CBLOCK - n);
151
0
            HASH_BLOCK_DATA_ORDER(c, p, 1);
152
0
            n = HASH_CBLOCK - n;
153
0
            data += n;
154
0
            len -= n;
155
0
            c->num = 0;
156
            /*
157
             * We use memset rather than OPENSSL_cleanse() here deliberately.
158
             * Using OPENSSL_cleanse() here could be a performance issue. It
159
             * will get properly cleansed on finalisation so this isn't a
160
             * security problem.
161
             */
162
0
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163
0
        } else {
164
0
            memcpy(p + n, data, len);
165
0
            c->num += (unsigned int)len;
166
0
            return 1;
167
0
        }
168
0
    }
169
170
93.6k
    n = len / HASH_CBLOCK;
171
93.6k
    if (n > 0) {
172
108
        HASH_BLOCK_DATA_ORDER(c, data, n);
173
108
        n *= HASH_CBLOCK;
174
108
        data += n;
175
108
        len -= n;
176
108
    }
177
178
93.6k
    if (len != 0) {
179
93.6k
        p = (unsigned char *)c->data;
180
93.6k
        c->num = (unsigned int)len;
181
93.6k
        memcpy(p, data, len);
182
93.6k
    }
183
93.6k
    return 1;
184
93.6k
}
Unexecuted instantiation: ossl_sm3_update
185
186
void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data)
187
0
{
188
0
    HASH_BLOCK_DATA_ORDER(c, data, 1);
189
0
}
Unexecuted instantiation: MD4_Transform
Unexecuted instantiation: MD5_Transform
Unexecuted instantiation: RIPEMD160_Transform
Unexecuted instantiation: SHA1_Transform
Unexecuted instantiation: SHA256_Transform
Unexecuted instantiation: ossl_sm3_transform
190
191
int HASH_FINAL(unsigned char *md, HASH_CTX *c)
192
350k
{
193
350k
    unsigned char *p = (unsigned char *)c->data;
194
350k
    size_t n = c->num;
195
196
350k
    p[n] = 0x80;                /* there is always room for one */
197
350k
    n++;
198
199
350k
    if (n > (HASH_CBLOCK - 8)) {
200
90
        memset(p + n, 0, HASH_CBLOCK - n);
201
90
        n = 0;
202
90
        HASH_BLOCK_DATA_ORDER(c, p, 1);
203
90
    }
204
350k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206
350k
    p += HASH_CBLOCK - 8;
207
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
208
110k
    (void)HOST_l2c(c->Nh, p);
209
110k
    (void)HOST_l2c(c->Nl, p);
210
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211
239k
    (void)HOST_l2c(c->Nl, p);
212
239k
    (void)HOST_l2c(c->Nh, p);
213
#endif
214
350k
    p -= HASH_CBLOCK;
215
350k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
216
350k
    c->num = 0;
217
350k
    OPENSSL_cleanse(p, HASH_CBLOCK);
218
219
#ifndef HASH_MAKE_STRING
220
# error "HASH_MAKE_STRING must be defined!"
221
#else
222
350k
    HASH_MAKE_STRING(c, md);
223
93.6k
#endif
224
225
93.6k
    return 1;
226
350k
}
Unexecuted instantiation: MD4_Final
MD5_Final
Line
Count
Source
192
34
{
193
34
    unsigned char *p = (unsigned char *)c->data;
194
34
    size_t n = c->num;
195
196
34
    p[n] = 0x80;                /* there is always room for one */
197
34
    n++;
198
199
34
    if (n > (HASH_CBLOCK - 8)) {
200
1
        memset(p + n, 0, HASH_CBLOCK - n);
201
1
        n = 0;
202
1
        HASH_BLOCK_DATA_ORDER(c, p, 1);
203
1
    }
204
34
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206
34
    p += HASH_CBLOCK - 8;
207
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
208
    (void)HOST_l2c(c->Nh, p);
209
    (void)HOST_l2c(c->Nl, p);
210
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211
34
    (void)HOST_l2c(c->Nl, p);
212
34
    (void)HOST_l2c(c->Nh, p);
213
34
#endif
214
34
    p -= HASH_CBLOCK;
215
34
    HASH_BLOCK_DATA_ORDER(c, p, 1);
216
34
    c->num = 0;
217
34
    OPENSSL_cleanse(p, HASH_CBLOCK);
218
219
#ifndef HASH_MAKE_STRING
220
# error "HASH_MAKE_STRING must be defined!"
221
#else
222
34
    HASH_MAKE_STRING(c, md);
223
34
#endif
224
225
34
    return 1;
226
34
}
RIPEMD160_Final
Line
Count
Source
192
239k
{
193
239k
    unsigned char *p = (unsigned char *)c->data;
194
239k
    size_t n = c->num;
195
196
239k
    p[n] = 0x80;                /* there is always room for one */
197
239k
    n++;
198
199
239k
    if (n > (HASH_CBLOCK - 8)) {
200
0
        memset(p + n, 0, HASH_CBLOCK - n);
201
0
        n = 0;
202
0
        HASH_BLOCK_DATA_ORDER(c, p, 1);
203
0
    }
204
239k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206
239k
    p += HASH_CBLOCK - 8;
207
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
208
    (void)HOST_l2c(c->Nh, p);
209
    (void)HOST_l2c(c->Nl, p);
210
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211
239k
    (void)HOST_l2c(c->Nl, p);
212
239k
    (void)HOST_l2c(c->Nh, p);
213
239k
#endif
214
239k
    p -= HASH_CBLOCK;
215
239k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
216
239k
    c->num = 0;
217
239k
    OPENSSL_cleanse(p, HASH_CBLOCK);
218
219
#ifndef HASH_MAKE_STRING
220
# error "HASH_MAKE_STRING must be defined!"
221
#else
222
239k
    HASH_MAKE_STRING(c, md);
223
239k
#endif
224
225
239k
    return 1;
226
239k
}
SHA1_Final
Line
Count
Source
192
17.2k
{
193
17.2k
    unsigned char *p = (unsigned char *)c->data;
194
17.2k
    size_t n = c->num;
195
196
17.2k
    p[n] = 0x80;                /* there is always room for one */
197
17.2k
    n++;
198
199
17.2k
    if (n > (HASH_CBLOCK - 8)) {
200
86
        memset(p + n, 0, HASH_CBLOCK - n);
201
86
        n = 0;
202
86
        HASH_BLOCK_DATA_ORDER(c, p, 1);
203
86
    }
204
17.2k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206
17.2k
    p += HASH_CBLOCK - 8;
207
17.2k
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
208
17.2k
    (void)HOST_l2c(c->Nh, p);
209
17.2k
    (void)HOST_l2c(c->Nl, p);
210
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211
    (void)HOST_l2c(c->Nl, p);
212
    (void)HOST_l2c(c->Nh, p);
213
#endif
214
17.2k
    p -= HASH_CBLOCK;
215
17.2k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
216
17.2k
    c->num = 0;
217
17.2k
    OPENSSL_cleanse(p, HASH_CBLOCK);
218
219
#ifndef HASH_MAKE_STRING
220
# error "HASH_MAKE_STRING must be defined!"
221
#else
222
17.2k
    HASH_MAKE_STRING(c, md);
223
17.2k
#endif
224
225
17.2k
    return 1;
226
17.2k
}
SHA256_Final
Line
Count
Source
192
93.6k
{
193
93.6k
    unsigned char *p = (unsigned char *)c->data;
194
93.6k
    size_t n = c->num;
195
196
93.6k
    p[n] = 0x80;                /* there is always room for one */
197
93.6k
    n++;
198
199
93.6k
    if (n > (HASH_CBLOCK - 8)) {
200
3
        memset(p + n, 0, HASH_CBLOCK - n);
201
3
        n = 0;
202
3
        HASH_BLOCK_DATA_ORDER(c, p, 1);
203
3
    }
204
93.6k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206
93.6k
    p += HASH_CBLOCK - 8;
207
93.6k
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
208
93.6k
    (void)HOST_l2c(c->Nh, p);
209
93.6k
    (void)HOST_l2c(c->Nl, p);
210
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211
    (void)HOST_l2c(c->Nl, p);
212
    (void)HOST_l2c(c->Nh, p);
213
#endif
214
93.6k
    p -= HASH_CBLOCK;
215
93.6k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
216
93.6k
    c->num = 0;
217
93.6k
    OPENSSL_cleanse(p, HASH_CBLOCK);
218
219
#ifndef HASH_MAKE_STRING
220
# error "HASH_MAKE_STRING must be defined!"
221
#else
222
93.6k
    HASH_MAKE_STRING(c, md);
223
93.6k
#endif
224
225
93.6k
    return 1;
226
93.6k
}
Unexecuted instantiation: ossl_sm3_final
227
228
#ifndef MD32_REG_T
229
# if defined(__alpha) || defined(__sparcv9) || defined(__mips)
230
#  define MD32_REG_T long
231
/*
232
 * This comment was originally written for MD5, which is why it
233
 * discusses A-D. But it basically applies to all 32-bit digests,
234
 * which is why it was moved to common header file.
235
 *
236
 * In case you wonder why A-D are declared as long and not
237
 * as MD5_LONG. Doing so results in slight performance
238
 * boost on LP64 architectures. The catch is we don't
239
 * really care if 32 MSBs of a 64-bit register get polluted
240
 * with eventual overflows as we *save* only 32 LSBs in
241
 * *either* case. Now declaring 'em long excuses the compiler
242
 * from keeping 32 MSBs zeroed resulting in 13% performance
243
 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
244
 * Well, to be honest it should say that this *prevents*
245
 * performance degradation.
246
 */
247
# else
248
/*
249
 * Above is not absolute and there are LP64 compilers that
250
 * generate better code if MD32_REG_T is defined int. The above
251
 * pre-processor condition reflects the circumstances under which
252
 * the conclusion was made and is subject to further extension.
253
 */
254
#  define MD32_REG_T int
255
# endif
256
#endif