1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the OpenSSL license (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#if !defined(OPENSSL_NO_MD5)
# include <openssl/evp.h>
# include <openssl/objects.h>
# include <openssl/x509.h>
# include <openssl/md5.h>
# include <openssl/sha.h>
# include "internal/cryptlib.h"
# include "crypto/evp.h"
# include <openssl/rsa.h>
struct md5_sha1_ctx {
MD5_CTX md5;
SHA_CTX sha1;
};
static int init(EVP_MD_CTX *ctx)
{
struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx);
if (!MD5_Init(&mctx->md5))
return 0;
return SHA1_Init(&mctx->sha1);
}
static int update(EVP_MD_CTX *ctx, const void *data, size_t count)
{
struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx);
if (!MD5_Update(&mctx->md5, data, count))
return 0;
return SHA1_Update(&mctx->sha1, data, count);
}
static int final(EVP_MD_CTX *ctx, unsigned char *md)
{
struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx);
if (!MD5_Final(md, &mctx->md5))
return 0;
return SHA1_Final(md + MD5_DIGEST_LENGTH, &mctx->sha1);
}
static int ctrl(EVP_MD_CTX *ctx, int cmd, int mslen, void *ms)
{
unsigned char padtmp[48];
unsigned char md5tmp[MD5_DIGEST_LENGTH];
unsigned char sha1tmp[SHA_DIGEST_LENGTH];
struct md5_sha1_ctx *mctx;
if (cmd != EVP_CTRL_SSL3_MASTER_SECRET)
return -2;
if (ctx == NULL)
return 0;
mctx = EVP_MD_CTX_md_data(ctx);
/* SSLv3 client auth handling: see RFC-6101 5.6.8 */
if (mslen != 48)
return 0;
/* At this point hash contains all handshake messages, update
* with master secret and pad_1.
*/
if (update(ctx, ms, mslen) <= 0)
return 0;
/* Set padtmp to pad_1 value */
memset(padtmp, 0x36, sizeof(padtmp));
if (!MD5_Update(&mctx->md5, padtmp, sizeof(padtmp)))
return 0;
if (!MD5_Final(md5tmp, &mctx->md5))
return 0;
if (!SHA1_Update(&mctx->sha1, padtmp, 40))
return 0;
if (!SHA1_Final(sha1tmp, &mctx->sha1))
return 0;
/* Reinitialise context */
if (!init(ctx))
return 0;
if (update(ctx, ms, mslen) <= 0)
return 0;
/* Set padtmp to pad_2 value */
memset(padtmp, 0x5c, sizeof(padtmp));
if (!MD5_Update(&mctx->md5, padtmp, sizeof(padtmp)))
return 0;
if (!MD5_Update(&mctx->md5, md5tmp, sizeof(md5tmp)))
return 0;
if (!SHA1_Update(&mctx->sha1, padtmp, 40))
return 0;
if (!SHA1_Update(&mctx->sha1, sha1tmp, sizeof(sha1tmp)))
return 0;
/* Now when ctx is finalised it will return the SSL v3 hash value */
OPENSSL_cleanse(md5tmp, sizeof(md5tmp));
OPENSSL_cleanse(sha1tmp, sizeof(sha1tmp));
return 1;
}
static const EVP_MD md5_sha1_md = {
NID_md5_sha1,
NID_md5_sha1,
MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH,
0,
init,
update,
final,
NULL,
NULL,
MD5_CBLOCK,
sizeof(EVP_MD *) + sizeof(struct md5_sha1_ctx),
ctrl
};
const EVP_MD *EVP_md5_sha1(void)
{
return &md5_sha1_md;
}
#endif
|
