/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 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 | } |
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 | } |
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 | } |
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 | } |
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 Line | Count | Source | 213 | 156k | { | 214 | 156k | HASH_BLOCK_DATA_ORDER(c, data, 1); | 215 | 156k | } |
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 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 | } |
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 | } |
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 | } |
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 | } |
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 |