1 /* $OpenBSD: m_sha1.c,v 1.19 2022/01/14 08:38:06 tb Exp $ */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58
59 #include <stdio.h>
60
61 #include <openssl/opensslconf.h>
62
63 #ifndef OPENSSL_NO_SHA
64
65 #include <openssl/evp.h>
66 #include <openssl/objects.h>
67 #include <openssl/sha.h>
68
69 #ifndef OPENSSL_NO_RSA
70 #include <openssl/rsa.h>
71 #endif
72
73 #include "evp_locl.h"
74
75 static int
init(EVP_MD_CTX * ctx)76 init(EVP_MD_CTX *ctx)
77 {
78 return SHA1_Init(ctx->md_data);
79 }
80
81 static int
update(EVP_MD_CTX * ctx,const void * data,size_t count)82 update(EVP_MD_CTX *ctx, const void *data, size_t count)
83 {
84 return SHA1_Update(ctx->md_data, data, count);
85 }
86
87 static int
final(EVP_MD_CTX * ctx,unsigned char * md)88 final(EVP_MD_CTX *ctx, unsigned char *md)
89 {
90 return SHA1_Final(md, ctx->md_data);
91 }
92
93 static const EVP_MD sha1_md = {
94 .type = NID_sha1,
95 .pkey_type = NID_sha1WithRSAEncryption,
96 .md_size = SHA_DIGEST_LENGTH,
97 .flags = EVP_MD_FLAG_DIGALGID_ABSENT,
98 .init = init,
99 .update = update,
100 .final = final,
101 .copy = NULL,
102 .cleanup = NULL,
103 .block_size = SHA_CBLOCK,
104 .ctx_size = sizeof(EVP_MD *) + sizeof(SHA_CTX),
105 };
106
107 const EVP_MD *
EVP_sha1(void)108 EVP_sha1(void)
109 {
110 return (&sha1_md);
111 }
112 #endif
113
114 #ifndef OPENSSL_NO_SHA256
115 static int
init224(EVP_MD_CTX * ctx)116 init224(EVP_MD_CTX *ctx)
117 {
118 return SHA224_Init(ctx->md_data);
119 }
120
121 static int
init256(EVP_MD_CTX * ctx)122 init256(EVP_MD_CTX *ctx)
123 {
124 return SHA256_Init(ctx->md_data);
125 }
126 /*
127 * Even though there're separate SHA224_[Update|Final], we call
128 * SHA256 functions even in SHA224 context. This is what happens
129 * there anyway, so we can spare few CPU cycles:-)
130 */
131 static int
update256(EVP_MD_CTX * ctx,const void * data,size_t count)132 update256(EVP_MD_CTX *ctx, const void *data, size_t count)
133 {
134 return SHA256_Update(ctx->md_data, data, count);
135 }
136
137 static int
final256(EVP_MD_CTX * ctx,unsigned char * md)138 final256(EVP_MD_CTX *ctx, unsigned char *md)
139 {
140 return SHA256_Final(md, ctx->md_data);
141 }
142
143 static const EVP_MD sha224_md = {
144 .type = NID_sha224,
145 .pkey_type = NID_sha224WithRSAEncryption,
146 .md_size = SHA224_DIGEST_LENGTH,
147 .flags = EVP_MD_FLAG_DIGALGID_ABSENT,
148 .init = init224,
149 .update = update256,
150 .final = final256,
151 .copy = NULL,
152 .cleanup = NULL,
153 .block_size = SHA256_CBLOCK,
154 .ctx_size = sizeof(EVP_MD *) + sizeof(SHA256_CTX),
155 };
156
157 const EVP_MD *
EVP_sha224(void)158 EVP_sha224(void)
159 {
160 return (&sha224_md);
161 }
162
163 static const EVP_MD sha256_md = {
164 .type = NID_sha256,
165 .pkey_type = NID_sha256WithRSAEncryption,
166 .md_size = SHA256_DIGEST_LENGTH,
167 .flags = EVP_MD_FLAG_DIGALGID_ABSENT,
168 .init = init256,
169 .update = update256,
170 .final = final256,
171 .copy = NULL,
172 .cleanup = NULL,
173 .block_size = SHA256_CBLOCK,
174 .ctx_size = sizeof(EVP_MD *) + sizeof(SHA256_CTX),
175 };
176
177 const EVP_MD *
EVP_sha256(void)178 EVP_sha256(void)
179 {
180 return (&sha256_md);
181 }
182 #endif /* ifndef OPENSSL_NO_SHA256 */
183
184 #ifndef OPENSSL_NO_SHA512
185 static int
init384(EVP_MD_CTX * ctx)186 init384(EVP_MD_CTX *ctx)
187 {
188 return SHA384_Init(ctx->md_data);
189 }
190
191 static int
init512(EVP_MD_CTX * ctx)192 init512(EVP_MD_CTX *ctx)
193 {
194 return SHA512_Init(ctx->md_data);
195 }
196 /* See comment in SHA224/256 section */
197 static int
update512(EVP_MD_CTX * ctx,const void * data,size_t count)198 update512(EVP_MD_CTX *ctx, const void *data, size_t count)
199 {
200 return SHA512_Update(ctx->md_data, data, count);
201 }
202
203 static int
final512(EVP_MD_CTX * ctx,unsigned char * md)204 final512(EVP_MD_CTX *ctx, unsigned char *md)
205 {
206 return SHA512_Final(md, ctx->md_data);
207 }
208
209 static const EVP_MD sha384_md = {
210 .type = NID_sha384,
211 .pkey_type = NID_sha384WithRSAEncryption,
212 .md_size = SHA384_DIGEST_LENGTH,
213 .flags = EVP_MD_FLAG_DIGALGID_ABSENT,
214 .init = init384,
215 .update = update512,
216 .final = final512,
217 .copy = NULL,
218 .cleanup = NULL,
219 .block_size = SHA512_CBLOCK,
220 .ctx_size = sizeof(EVP_MD *) + sizeof(SHA512_CTX),
221 };
222
223 const EVP_MD *
EVP_sha384(void)224 EVP_sha384(void)
225 {
226 return (&sha384_md);
227 }
228
229 static const EVP_MD sha512_md = {
230 .type = NID_sha512,
231 .pkey_type = NID_sha512WithRSAEncryption,
232 .md_size = SHA512_DIGEST_LENGTH,
233 .flags = EVP_MD_FLAG_DIGALGID_ABSENT,
234 .init = init512,
235 .update = update512,
236 .final = final512,
237 .copy = NULL,
238 .cleanup = NULL,
239 .block_size = SHA512_CBLOCK,
240 .ctx_size = sizeof(EVP_MD *) + sizeof(SHA512_CTX),
241 };
242
243 const EVP_MD *
EVP_sha512(void)244 EVP_sha512(void)
245 {
246 return (&sha512_md);
247 }
248 #endif /* ifndef OPENSSL_NO_SHA512 */
249