4f009560b338e6fbd4671834fffde438ce7ddfb4
[openssl.git] / crypto / evp / m_sha1.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 #include <stdio.h>
11 #include "internal/cryptlib.h"
12
13 #include <openssl/evp.h>
14 #include <openssl/objects.h>
15 #include <openssl/sha.h>
16 #include <openssl/rsa.h>
17 #include "internal/evp_int.h"
18
19 static int init(EVP_MD_CTX *ctx)
20 {
21     return SHA1_Init(EVP_MD_CTX_md_data(ctx));
22 }
23
24 static int update(EVP_MD_CTX *ctx, const void *data, size_t count)
25 {
26     return SHA1_Update(EVP_MD_CTX_md_data(ctx), data, count);
27 }
28
29 static int final(EVP_MD_CTX *ctx, unsigned char *md)
30 {
31     return SHA1_Final(md, EVP_MD_CTX_md_data(ctx));
32 }
33
34 static int ctrl(EVP_MD_CTX *ctx, int cmd, int mslen, void *ms)
35 {
36     unsigned char padtmp[40];
37     unsigned char sha1tmp[SHA_DIGEST_LENGTH];
38
39     SHA_CTX *sha1 = EVP_MD_CTX_md_data(ctx);
40
41     if (cmd != EVP_CTRL_SSL3_MASTER_SECRET)
42         return 0;
43
44     /* SSLv3 client auth handling: see RFC-6101 5.6.8 */
45     if (mslen != 48)
46         return 0;
47
48     /* At this point hash contains all handshake messages, update
49      * with master secret and pad_1.
50      */
51
52     if (SHA1_Update(sha1, ms, mslen) <= 0)
53         return 0;
54
55     /* Set padtmp to pad_1 value */
56     memset(padtmp, 0x36, sizeof(padtmp));
57
58     if (!SHA1_Update(sha1, padtmp, sizeof(padtmp)))
59         return 0;
60
61     if (!SHA1_Final(sha1tmp, sha1))
62         return 0;
63
64     /* Reinitialise context */
65
66     if (!SHA1_Init(sha1))
67         return 0;
68
69     if (SHA1_Update(sha1, ms, mslen) <= 0)
70         return 0;
71
72     /* Set padtmp to pad_2 value */
73     memset(padtmp, 0x5c, sizeof(padtmp));
74
75     if (!SHA1_Update(sha1, padtmp, sizeof(padtmp)))
76         return 0;
77
78     if (!SHA1_Update(sha1, sha1tmp, sizeof(sha1tmp)))
79         return 0;
80
81     /* Now when ctx is finalised it will return the SSL v3 hash value */
82     OPENSSL_cleanse(sha1tmp, sizeof(sha1tmp));
83
84     return 1;
85
86 }
87
88 static const EVP_MD sha1_md = {
89     NID_sha1,
90     NID_sha1WithRSAEncryption,
91     SHA_DIGEST_LENGTH,
92     EVP_MD_FLAG_DIGALGID_ABSENT,
93     init,
94     update,
95     final,
96     NULL,
97     NULL,
98     SHA_CBLOCK,
99     sizeof(EVP_MD *) + sizeof(SHA_CTX),
100     ctrl
101 };
102
103 const EVP_MD *EVP_sha1(void)
104 {
105     return (&sha1_md);
106 }
107
108 static int init224(EVP_MD_CTX *ctx)
109 {
110     return SHA224_Init(EVP_MD_CTX_md_data(ctx));
111 }
112
113 static int init256(EVP_MD_CTX *ctx)
114 {
115     return SHA256_Init(EVP_MD_CTX_md_data(ctx));
116 }
117
118 /*
119  * Even though there're separate SHA224_[Update|Final], we call
120  * SHA256 functions even in SHA224 context. This is what happens
121  * there anyway, so we can spare few CPU cycles:-)
122  */
123 static int update256(EVP_MD_CTX *ctx, const void *data, size_t count)
124 {
125     return SHA256_Update(EVP_MD_CTX_md_data(ctx), data, count);
126 }
127
128 static int final256(EVP_MD_CTX *ctx, unsigned char *md)
129 {
130     return SHA256_Final(md, EVP_MD_CTX_md_data(ctx));
131 }
132
133 static const EVP_MD sha224_md = {
134     NID_sha224,
135     NID_sha224WithRSAEncryption,
136     SHA224_DIGEST_LENGTH,
137     EVP_MD_FLAG_DIGALGID_ABSENT,
138     init224,
139     update256,
140     final256,
141     NULL,
142     NULL,
143     SHA256_CBLOCK,
144     sizeof(EVP_MD *) + sizeof(SHA256_CTX),
145 };
146
147 const EVP_MD *EVP_sha224(void)
148 {
149     return (&sha224_md);
150 }
151
152 static const EVP_MD sha256_md = {
153     NID_sha256,
154     NID_sha256WithRSAEncryption,
155     SHA256_DIGEST_LENGTH,
156     EVP_MD_FLAG_DIGALGID_ABSENT,
157     init256,
158     update256,
159     final256,
160     NULL,
161     NULL,
162     SHA256_CBLOCK,
163     sizeof(EVP_MD *) + sizeof(SHA256_CTX),
164 };
165
166 const EVP_MD *EVP_sha256(void)
167 {
168     return (&sha256_md);
169 }
170
171 static int init384(EVP_MD_CTX *ctx)
172 {
173     return SHA384_Init(EVP_MD_CTX_md_data(ctx));
174 }
175
176 static int init512(EVP_MD_CTX *ctx)
177 {
178     return SHA512_Init(EVP_MD_CTX_md_data(ctx));
179 }
180
181 /* See comment in SHA224/256 section */
182 static int update512(EVP_MD_CTX *ctx, const void *data, size_t count)
183 {
184     return SHA512_Update(EVP_MD_CTX_md_data(ctx), data, count);
185 }
186
187 static int final512(EVP_MD_CTX *ctx, unsigned char *md)
188 {
189     return SHA512_Final(md, EVP_MD_CTX_md_data(ctx));
190 }
191
192 static const EVP_MD sha384_md = {
193     NID_sha384,
194     NID_sha384WithRSAEncryption,
195     SHA384_DIGEST_LENGTH,
196     EVP_MD_FLAG_DIGALGID_ABSENT,
197     init384,
198     update512,
199     final512,
200     NULL,
201     NULL,
202     SHA512_CBLOCK,
203     sizeof(EVP_MD *) + sizeof(SHA512_CTX),
204 };
205
206 const EVP_MD *EVP_sha384(void)
207 {
208     return (&sha384_md);
209 }
210
211 static const EVP_MD sha512_md = {
212     NID_sha512,
213     NID_sha512WithRSAEncryption,
214     SHA512_DIGEST_LENGTH,
215     EVP_MD_FLAG_DIGALGID_ABSENT,
216     init512,
217     update512,
218     final512,
219     NULL,
220     NULL,
221     SHA512_CBLOCK,
222     sizeof(EVP_MD *) + sizeof(SHA512_CTX),
223 };
224
225 const EVP_MD *EVP_sha512(void)
226 {
227     return (&sha512_md);
228 }