Coverage Report

Created: 2024-11-21 07:03

/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
971M
# 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
33.4M
#  define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))<<24),          \
127
33.4M
                         l|=(((unsigned long)(*((c)++)))<<16),          \
128
33.4M
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
129
33.4M
                         l|=(((unsigned long)(*((c)++)))    )           )
130
7.26M
#  define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)>>24)&0xff),      \
131
7.26M
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
132
7.26M
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
133
7.26M
                         *((c)++)=(unsigned char)(((l)    )&0xff),      \
134
7.26M
                         l)
135
136
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
137
138
13.2M
#  define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))    ),          \
139
13.2M
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
140
13.2M
                         l|=(((unsigned long)(*((c)++)))<<16),          \
141
13.2M
                         l|=(((unsigned long)(*((c)++)))<<24)           )
142
267k
#  define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)    )&0xff),      \
143
267k
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
144
267k
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
145
267k
                         *((c)++)=(unsigned char)(((l)>>24)&0xff),      \
146
267k
                         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
1.17M
{
156
1.17M
    const unsigned char *data = data_;
157
1.17M
    unsigned char *p;
158
1.17M
    HASH_LONG l;
159
1.17M
    size_t n;
160
161
1.17M
    if (len == 0)
162
0
        return 1;
163
164
1.17M
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
1.17M
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
1.17M
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
1.17M
    c->Nl = l;
170
171
1.17M
    n = c->num;
172
1.17M
    if (n != 0) {
173
95.0k
        p = (unsigned char *)c->data;
174
175
95.0k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
41.6k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
41.6k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
41.6k
            n = HASH_CBLOCK - n;
179
41.6k
            data += n;
180
41.6k
            len -= n;
181
41.6k
            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
41.6k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
53.4k
        } else {
190
53.4k
            memcpy(p + n, data, len);
191
53.4k
            c->num += (unsigned int)len;
192
53.4k
            return 1;
193
53.4k
        }
194
95.0k
    }
195
196
1.11M
    n = len / HASH_CBLOCK;
197
1.11M
    if (n > 0) {
198
54.6k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
54.6k
        n *= HASH_CBLOCK;
200
54.6k
        data += n;
201
54.6k
        len -= n;
202
54.6k
    }
203
204
1.11M
    if (len != 0) {
205
1.10M
        p = (unsigned char *)c->data;
206
1.10M
        c->num = (unsigned int)len;
207
1.10M
        memcpy(p, data, len);
208
1.10M
    }
209
1.11M
    return 1;
210
1.17M
}
MD5_Update
Line
Count
Source
155
44.0k
{
156
44.0k
    const unsigned char *data = data_;
157
44.0k
    unsigned char *p;
158
44.0k
    HASH_LONG l;
159
44.0k
    size_t n;
160
161
44.0k
    if (len == 0)
162
0
        return 1;
163
164
44.0k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
44.0k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
44.0k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
44.0k
    c->Nl = l;
170
171
44.0k
    n = c->num;
172
44.0k
    if (n != 0) {
173
25.5k
        p = (unsigned char *)c->data;
174
175
25.5k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
11.3k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
11.3k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
11.3k
            n = HASH_CBLOCK - n;
179
11.3k
            data += n;
180
11.3k
            len -= n;
181
11.3k
            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
11.3k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
14.1k
        } else {
190
14.1k
            memcpy(p + n, data, len);
191
14.1k
            c->num += (unsigned int)len;
192
14.1k
            return 1;
193
14.1k
        }
194
25.5k
    }
195
196
29.8k
    n = len / HASH_CBLOCK;
197
29.8k
    if (n > 0) {
198
13.0k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
13.0k
        n *= HASH_CBLOCK;
200
13.0k
        data += n;
201
13.0k
        len -= n;
202
13.0k
    }
203
204
29.8k
    if (len != 0) {
205
27.6k
        p = (unsigned char *)c->data;
206
27.6k
        c->num = (unsigned int)len;
207
27.6k
        memcpy(p, data, len);
208
27.6k
    }
209
29.8k
    return 1;
210
44.0k
}
RIPEMD160_Update
Line
Count
Source
155
18.4k
{
156
18.4k
    const unsigned char *data = data_;
157
18.4k
    unsigned char *p;
158
18.4k
    HASH_LONG l;
159
18.4k
    size_t n;
160
161
18.4k
    if (len == 0)
162
0
        return 1;
163
164
18.4k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
18.4k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
18.4k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
18.4k
    c->Nl = l;
170
171
18.4k
    n = c->num;
172
18.4k
    if (n != 0) {
173
9.26k
        p = (unsigned char *)c->data;
174
175
9.26k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
4.32k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
4.32k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
4.32k
            n = HASH_CBLOCK - n;
179
4.32k
            data += n;
180
4.32k
            len -= n;
181
4.32k
            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
4.32k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
4.94k
        } else {
190
4.94k
            memcpy(p + n, data, len);
191
4.94k
            c->num += (unsigned int)len;
192
4.94k
            return 1;
193
4.94k
        }
194
9.26k
    }
195
196
13.5k
    n = len / HASH_CBLOCK;
197
13.5k
    if (n > 0) {
198
5.89k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
5.89k
        n *= HASH_CBLOCK;
200
5.89k
        data += n;
201
5.89k
        len -= n;
202
5.89k
    }
203
204
13.5k
    if (len != 0) {
205
11.3k
        p = (unsigned char *)c->data;
206
11.3k
        c->num = (unsigned int)len;
207
11.3k
        memcpy(p, data, len);
208
11.3k
    }
209
13.5k
    return 1;
210
18.4k
}
SHA1_Update
Line
Count
Source
155
1.01M
{
156
1.01M
    const unsigned char *data = data_;
157
1.01M
    unsigned char *p;
158
1.01M
    HASH_LONG l;
159
1.01M
    size_t n;
160
161
1.01M
    if (len == 0)
162
0
        return 1;
163
164
1.01M
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
1.01M
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
1.01M
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
1.01M
    c->Nl = l;
170
171
1.01M
    n = c->num;
172
1.01M
    if (n != 0) {
173
12.3k
        p = (unsigned char *)c->data;
174
175
12.3k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
5.75k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
5.75k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
5.75k
            n = HASH_CBLOCK - n;
179
5.75k
            data += n;
180
5.75k
            len -= n;
181
5.75k
            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
5.75k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
6.63k
        } else {
190
6.63k
            memcpy(p + n, data, len);
191
6.63k
            c->num += (unsigned int)len;
192
6.63k
            return 1;
193
6.63k
        }
194
12.3k
    }
195
196
1.00M
    n = len / HASH_CBLOCK;
197
1.00M
    if (n > 0) {
198
7.14k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
7.14k
        n *= HASH_CBLOCK;
200
7.14k
        data += n;
201
7.14k
        len -= n;
202
7.14k
    }
203
204
1.00M
    if (len != 0) {
205
1.00M
        p = (unsigned char *)c->data;
206
1.00M
        c->num = (unsigned int)len;
207
1.00M
        memcpy(p, data, len);
208
1.00M
    }
209
1.00M
    return 1;
210
1.01M
}
SHA256_Update
Line
Count
Source
155
33.8k
{
156
33.8k
    const unsigned char *data = data_;
157
33.8k
    unsigned char *p;
158
33.8k
    HASH_LONG l;
159
33.8k
    size_t n;
160
161
33.8k
    if (len == 0)
162
0
        return 1;
163
164
33.8k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
33.8k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
33.8k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
33.8k
    c->Nl = l;
170
171
33.8k
    n = c->num;
172
33.8k
    if (n != 0) {
173
12.9k
        p = (unsigned char *)c->data;
174
175
12.9k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
4.54k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
4.54k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
4.54k
            n = HASH_CBLOCK - n;
179
4.54k
            data += n;
180
4.54k
            len -= n;
181
4.54k
            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
4.54k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
8.39k
        } else {
190
8.39k
            memcpy(p + n, data, len);
191
8.39k
            c->num += (unsigned int)len;
192
8.39k
            return 1;
193
8.39k
        }
194
12.9k
    }
195
196
25.4k
    n = len / HASH_CBLOCK;
197
25.4k
    if (n > 0) {
198
10.3k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
10.3k
        n *= HASH_CBLOCK;
200
10.3k
        data += n;
201
10.3k
        len -= n;
202
10.3k
    }
203
204
25.4k
    if (len != 0) {
205
21.7k
        p = (unsigned char *)c->data;
206
21.7k
        c->num = (unsigned int)len;
207
21.7k
        memcpy(p, data, len);
208
21.7k
    }
209
25.4k
    return 1;
210
33.8k
}
ossl_sm3_update
Line
Count
Source
155
18.4k
{
156
18.4k
    const unsigned char *data = data_;
157
18.4k
    unsigned char *p;
158
18.4k
    HASH_LONG l;
159
18.4k
    size_t n;
160
161
18.4k
    if (len == 0)
162
0
        return 1;
163
164
18.4k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
18.4k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
18.4k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
18.4k
    c->Nl = l;
170
171
18.4k
    n = c->num;
172
18.4k
    if (n != 0) {
173
9.27k
        p = (unsigned char *)c->data;
174
175
9.27k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
4.22k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
4.22k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
4.22k
            n = HASH_CBLOCK - n;
179
4.22k
            data += n;
180
4.22k
            len -= n;
181
4.22k
            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
4.22k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
5.05k
        } else {
190
5.05k
            memcpy(p + n, data, len);
191
5.05k
            c->num += (unsigned int)len;
192
5.05k
            return 1;
193
5.05k
        }
194
9.27k
    }
195
196
13.3k
    n = len / HASH_CBLOCK;
197
13.3k
    if (n > 0) {
198
5.19k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
5.19k
        n *= HASH_CBLOCK;
200
5.19k
        data += n;
201
5.19k
        len -= n;
202
5.19k
    }
203
204
13.3k
    if (len != 0) {
205
11.6k
        p = (unsigned char *)c->data;
206
11.6k
        c->num = (unsigned int)len;
207
11.6k
        memcpy(p, data, len);
208
11.6k
    }
209
13.3k
    return 1;
210
18.4k
}
MD5_Update
Line
Count
Source
155
44.0k
{
156
44.0k
    const unsigned char *data = data_;
157
44.0k
    unsigned char *p;
158
44.0k
    HASH_LONG l;
159
44.0k
    size_t n;
160
161
44.0k
    if (len == 0)
162
0
        return 1;
163
164
44.0k
    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
165
44.0k
    if (l < c->Nl)              /* overflow */
166
0
        c->Nh++;
167
44.0k
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
168
                                       * 16-bit */
169
44.0k
    c->Nl = l;
170
171
44.0k
    n = c->num;
172
44.0k
    if (n != 0) {
173
25.5k
        p = (unsigned char *)c->data;
174
175
25.5k
        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
176
11.3k
            memcpy(p + n, data, HASH_CBLOCK - n);
177
11.3k
            HASH_BLOCK_DATA_ORDER(c, p, 1);
178
11.3k
            n = HASH_CBLOCK - n;
179
11.3k
            data += n;
180
11.3k
            len -= n;
181
11.3k
            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
11.3k
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
189
14.1k
        } else {
190
14.1k
            memcpy(p + n, data, len);
191
14.1k
            c->num += (unsigned int)len;
192
14.1k
            return 1;
193
14.1k
        }
194
25.5k
    }
195
196
29.8k
    n = len / HASH_CBLOCK;
197
29.8k
    if (n > 0) {
198
13.0k
        HASH_BLOCK_DATA_ORDER(c, data, n);
199
13.0k
        n *= HASH_CBLOCK;
200
13.0k
        data += n;
201
13.0k
        len -= n;
202
13.0k
    }
203
204
29.8k
    if (len != 0) {
205
27.6k
        p = (unsigned char *)c->data;
206
27.6k
        c->num = (unsigned int)len;
207
27.6k
        memcpy(p, data, len);
208
27.6k
    }
209
29.8k
    return 1;
210
44.0k
}
211
212
void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data)
213
0
{
214
0
    HASH_BLOCK_DATA_ORDER(c, data, 1);
215
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
Unexecuted instantiation: MD5_Transform
216
217
int HASH_FINAL(unsigned char *md, HASH_CTX *c)
218
1.06M
{
219
1.06M
    unsigned char *p = (unsigned char *)c->data;
220
1.06M
    size_t n = c->num;
221
222
1.06M
    p[n] = 0x80;                /* there is always room for one */
223
1.06M
    n++;
224
225
1.06M
    if (n > (HASH_CBLOCK - 8)) {
226
7.15k
        memset(p + n, 0, HASH_CBLOCK - n);
227
7.15k
        n = 0;
228
7.15k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
7.15k
    }
230
1.06M
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
1.06M
    p += HASH_CBLOCK - 8;
233
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
1.02M
    (void)HOST_l2c(c->Nh, p);
235
1.02M
    (void)HOST_l2c(c->Nl, p);
236
# elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
237
43.2k
    (void)HOST_l2c(c->Nl, p);
238
43.2k
    (void)HOST_l2c(c->Nh, p);
239
# endif
240
1.06M
    p -= HASH_CBLOCK;
241
1.06M
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
1.06M
    c->num = 0;
243
1.06M
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
1.06M
    HASH_MAKE_STRING(c, md);
249
18.1k
# endif
250
251
18.1k
    return 1;
252
1.06M
}
MD5_Final
Line
Count
Source
218
17.5k
{
219
17.5k
    unsigned char *p = (unsigned char *)c->data;
220
17.5k
    size_t n = c->num;
221
222
17.5k
    p[n] = 0x80;                /* there is always room for one */
223
17.5k
    n++;
224
225
17.5k
    if (n > (HASH_CBLOCK - 8)) {
226
2.13k
        memset(p + n, 0, HASH_CBLOCK - n);
227
2.13k
        n = 0;
228
2.13k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
2.13k
    }
230
17.5k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
17.5k
    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
17.5k
    (void)HOST_l2c(c->Nl, p);
238
17.5k
    (void)HOST_l2c(c->Nh, p);
239
17.5k
# endif
240
17.5k
    p -= HASH_CBLOCK;
241
17.5k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
17.5k
    c->num = 0;
243
17.5k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
17.5k
    HASH_MAKE_STRING(c, md);
249
17.5k
# endif
250
251
17.5k
    return 1;
252
17.5k
}
RIPEMD160_Final
Line
Count
Source
218
8.04k
{
219
8.04k
    unsigned char *p = (unsigned char *)c->data;
220
8.04k
    size_t n = c->num;
221
222
8.04k
    p[n] = 0x80;                /* there is always room for one */
223
8.04k
    n++;
224
225
8.04k
    if (n > (HASH_CBLOCK - 8)) {
226
248
        memset(p + n, 0, HASH_CBLOCK - n);
227
248
        n = 0;
228
248
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
248
    }
230
8.04k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
8.04k
    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
8.04k
    (void)HOST_l2c(c->Nl, p);
238
8.04k
    (void)HOST_l2c(c->Nh, p);
239
8.04k
# endif
240
8.04k
    p -= HASH_CBLOCK;
241
8.04k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
8.04k
    c->num = 0;
243
8.04k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
8.04k
    HASH_MAKE_STRING(c, md);
249
8.04k
# endif
250
251
8.04k
    return 1;
252
8.04k
}
SHA1_Final
Line
Count
Source
218
999k
{
219
999k
    unsigned char *p = (unsigned char *)c->data;
220
999k
    size_t n = c->num;
221
222
999k
    p[n] = 0x80;                /* there is always room for one */
223
999k
    n++;
224
225
999k
    if (n > (HASH_CBLOCK - 8)) {
226
1.27k
        memset(p + n, 0, HASH_CBLOCK - n);
227
1.27k
        n = 0;
228
1.27k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
1.27k
    }
230
999k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
999k
    p += HASH_CBLOCK - 8;
233
999k
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
999k
    (void)HOST_l2c(c->Nh, p);
235
999k
    (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
999k
    p -= HASH_CBLOCK;
241
999k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
999k
    c->num = 0;
243
999k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
999k
    HASH_MAKE_STRING(c, md);
249
999k
# endif
250
251
999k
    return 1;
252
999k
}
SHA256_Final
Line
Count
Source
218
18.1k
{
219
18.1k
    unsigned char *p = (unsigned char *)c->data;
220
18.1k
    size_t n = c->num;
221
222
18.1k
    p[n] = 0x80;                /* there is always room for one */
223
18.1k
    n++;
224
225
18.1k
    if (n > (HASH_CBLOCK - 8)) {
226
847
        memset(p + n, 0, HASH_CBLOCK - n);
227
847
        n = 0;
228
847
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
847
    }
230
18.1k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
18.1k
    p += HASH_CBLOCK - 8;
233
18.1k
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
18.1k
    (void)HOST_l2c(c->Nh, p);
235
18.1k
    (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
18.1k
    p -= HASH_CBLOCK;
241
18.1k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
18.1k
    c->num = 0;
243
18.1k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
18.1k
    HASH_MAKE_STRING(c, md);
249
18.1k
# endif
250
251
18.1k
    return 1;
252
18.1k
}
ossl_sm3_final
Line
Count
Source
218
8.45k
{
219
8.45k
    unsigned char *p = (unsigned char *)c->data;
220
8.45k
    size_t n = c->num;
221
222
8.45k
    p[n] = 0x80;                /* there is always room for one */
223
8.45k
    n++;
224
225
8.45k
    if (n > (HASH_CBLOCK - 8)) {
226
511
        memset(p + n, 0, HASH_CBLOCK - n);
227
511
        n = 0;
228
511
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
511
    }
230
8.45k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
8.45k
    p += HASH_CBLOCK - 8;
233
8.45k
# if   defined(DATA_ORDER_IS_BIG_ENDIAN)
234
8.45k
    (void)HOST_l2c(c->Nh, p);
235
8.45k
    (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
8.45k
    p -= HASH_CBLOCK;
241
8.45k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
8.45k
    c->num = 0;
243
8.45k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
8.45k
    HASH_MAKE_STRING(c, md);
249
8.45k
# endif
250
251
8.45k
    return 1;
252
8.45k
}
MD5_Final
Line
Count
Source
218
17.5k
{
219
17.5k
    unsigned char *p = (unsigned char *)c->data;
220
17.5k
    size_t n = c->num;
221
222
17.5k
    p[n] = 0x80;                /* there is always room for one */
223
17.5k
    n++;
224
225
17.5k
    if (n > (HASH_CBLOCK - 8)) {
226
2.13k
        memset(p + n, 0, HASH_CBLOCK - n);
227
2.13k
        n = 0;
228
2.13k
        HASH_BLOCK_DATA_ORDER(c, p, 1);
229
2.13k
    }
230
17.5k
    memset(p + n, 0, HASH_CBLOCK - 8 - n);
231
232
17.5k
    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
17.5k
    (void)HOST_l2c(c->Nl, p);
238
17.5k
    (void)HOST_l2c(c->Nh, p);
239
17.5k
# endif
240
17.5k
    p -= HASH_CBLOCK;
241
17.5k
    HASH_BLOCK_DATA_ORDER(c, p, 1);
242
17.5k
    c->num = 0;
243
17.5k
    OPENSSL_cleanse(p, HASH_CBLOCK);
244
245
# ifndef HASH_MAKE_STRING
246
#  error "HASH_MAKE_STRING must be defined!"
247
# else
248
17.5k
    HASH_MAKE_STRING(c, md);
249
17.5k
# endif
250
251
17.5k
    return 1;
252
17.5k
}
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