xref: /lighttpd1.4/src/sys-crypto-md.h (revision 9570cc2f) 
1 /* sys-crypto-md.h - message digest (MD) wrapper
2  *
3  * message digest (MD) algorithms are not necessarily cryptographically secure
4  * (often provided by crypto libraries, hence this file named sys-crypto-md.h)
5  *
6  * Copyright(c) 2020 Glenn Strauss gstrauss()gluelogic.com  All rights reserved
7  * License: BSD 3-clause (same as lighttpd)
8  */
9 #ifndef LI_SYS_CRYPTO_MD_H
10 #define LI_SYS_CRYPTO_MD_H
11 #include "first.h"
12 
13 #include "sys-crypto.h" /* USE_LIB_CRYPTO */
14 #ifdef USE_LIB_CRYPTO
15 
16 #if defined(USE_NETTLE_CRYPTO)
17 
18 #include <nettle/md4.h>
19 #include <nettle/md5.h>
20 #include <nettle/sha.h>
21 
22 #define USE_LIB_CRYPTO_MD4
23 typedef struct md4_ctx MD4_CTX;
24 #define MD4_Init(ctx) \
25         nettle_md4_init(ctx)
26 #define MD4_Final(digest, ctx) \
27         nettle_md4_digest((ctx),sizeof(digest),(digest))
28 static inline void
29 MD4_Update(MD4_CTX *ctx, const void *data, size_t length)
30 {
31     nettle_md4_update(ctx, length, data);
32 }
33 
34 #define USE_LIB_CRYPTO_MD5
35 typedef struct md5_ctx MD5_CTX;
36 #define MD5_Init(ctx) \
37         nettle_md5_init(ctx)
38 #define MD5_Final(digest, ctx) \
39         nettle_md5_digest((ctx),sizeof(digest),(digest))
40 static inline void
41 MD5_Update(MD5_CTX *ctx, const void *data, size_t length)
42 {
43     nettle_md5_update(ctx, length, data);
44 }
45 
46 #define USE_LIB_CRYPTO_SHA1
47 typedef struct sha1_ctx SHA_CTX;
48 #define SHA1_Init(ctx) \
49         nettle_sha1_init(ctx)
50 #define SHA1_Final(digest, ctx) \
51         nettle_sha1_digest((ctx),sizeof(digest),(digest))
52 static inline void
53 SHA1_Update(SHA_CTX *ctx, const void *data, size_t length)
54 {
55     nettle_sha1_update(ctx, length, data);
56 }
57 
58 #define USE_LIB_CRYPTO_SHA256
59 typedef struct sha256_ctx SHA256_CTX;
60 #define SHA256_Init(ctx) \
61         nettle_sha256_init(ctx)
62 #define SHA256_Final(digest, ctx) \
63         nettle_sha256_digest((ctx),sizeof(digest),(digest))
64 static inline void
65 SHA256_Update(SHA256_CTX *ctx, const void *data, size_t length)
66 {
67     nettle_sha256_update(ctx, length, data);
68 }
69 
70 #define USE_LIB_CRYPTO_SHA512_256
71 #ifndef SHA512_256_DIGEST_LENGTH
72 #define SHA512_256_DIGEST_LENGTH 32
73 #endif
74 typedef struct sha512_256_ctx SHA512_CTX;    /*(yes, SHA512_CTX)*/
75 #define SHA512_256_Init(ctx) \
76         nettle_sha512_256_init(ctx)
77 #define SHA512_256_Final(digest, ctx) \
78         nettle_sha512_256_digest((ctx),sizeof(digest),(digest))
79 static inline void
80 SHA512_256_Update(SHA512_CTX *ctx, const void *data, size_t length)
81 {
82     nettle_sha512_update(ctx, length, data); /*(yes, nettle_sha512_update())*/
83 }
84 
85 #elif defined(USE_MBEDTLS_CRYPTO)
86 
87 #ifdef MBEDTLS_MD4_C
88 #define USE_LIB_CRYPTO_MD4
89 #include <mbedtls/md4.h>
90 typedef struct mbedtls_md4_context MD4_CTX;
91 #define MD4_Init(ctx) \
92         (mbedtls_md4_init(ctx), mbedtls_md4_starts_ret(ctx))
93 #define MD4_Final(digest, ctx) \
94         (mbedtls_md4_finish_ret((ctx),(digest)), mbedtls_md4_free(ctx))
95 static inline void
96 MD4_Update(MD4_CTX *ctx, const void *data, size_t length)
97 {
98     mbedtls_md4_update_ret(ctx, data, length);
99 }
100 #endif
101 
102 #ifdef MBEDTLS_MD5_C
103 #define USE_LIB_CRYPTO_MD5
104 #include <mbedtls/md5.h>
105 typedef struct mbedtls_md5_context MD5_CTX;
106 #define MD5_Init(ctx) \
107         (mbedtls_md5_init(ctx), mbedtls_md5_starts_ret(ctx))
108 #define MD5_Final(digest, ctx) \
109         (mbedtls_md5_finish_ret((ctx),(digest)), mbedtls_md5_free(ctx))
110 static inline void
111 MD5_Update(MD5_CTX *ctx, const void *data, size_t length)
112 {
113     mbedtls_md5_update_ret(ctx, data, length);
114 }
115 #endif
116 
117 #ifdef MBEDTLS_SHA1_C
118 #define USE_LIB_CRYPTO_SHA1
119 #include <mbedtls/sha1.h>
120 typedef struct mbedtls_sha1_context SHA_CTX;
121 #define SHA1_Init(ctx) \
122         (mbedtls_sha1_init(ctx), mbedtls_sha1_starts_ret(ctx))
123 #define SHA1_Final(digest, ctx) \
124         (mbedtls_sha1_finish_ret((ctx),(digest)), mbedtls_sha1_free(ctx))
125 static inline void
126 SHA1_Update(SHA_CTX *ctx, const void *data, size_t length)
127 {
128     mbedtls_sha1_update_ret(ctx, data, length);
129 }
130 #endif
131 
132 #ifdef MBEDTLS_SHA256_C
133 #define USE_LIB_CRYPTO_SHA256
134 #include <mbedtls/sha256.h>
135 typedef struct mbedtls_sha256_context SHA256_CTX;
136 #define SHA256_Init(ctx) \
137         (mbedtls_sha256_init(ctx), mbedtls_sha256_starts_ret((ctx),0))
138 #define SHA256_Final(digest, ctx) \
139         (mbedtls_sha256_finish_ret((ctx),(digest)), mbedtls_sha256_free(ctx))
140 static inline void
141 SHA256_Update(SHA256_CTX *ctx, const void *data, size_t length)
142 {
143     mbedtls_sha256_update_ret(ctx, data, length);
144 }
145 #endif
146 
147 #elif defined(USE_OPENSSL_CRYPTO)
148 
149 #include <openssl/md4.h>
150 #include <openssl/md5.h>
151 #include <openssl/sha.h>
152 #ifndef OPENSSL_NO_MD4
153 #ifndef NO_MD4 /*(e.g. wolfSSL built without MD4)*/
154 #define USE_LIB_CRYPTO_MD4
155 #endif
156 #endif
157 #ifndef OPENSSL_NO_MD5
158 #define USE_LIB_CRYPTO_MD5
159 #endif
160 #define USE_LIB_CRYPTO_SHA1
161 #define USE_LIB_CRYPTO_SHA256
162 #ifdef SHA512_256_DIGEST_LENGTH
163 #define USE_LIB_CRYPTO_SHA512_256
164 #endif
165 
166 #elif defined(USE_GNUTLS_CRYPTO)
167 
168 #include <gnutls/crypto.h>
169 
170 #define USE_LIB_CRYPTO_MD5
171 typedef gnutls_hash_hd_t MD5_CTX;
172 #define MD5_Init(ctx)                                        \
173         do {                                                  \
174             if (gnutls_hash_init((ctx), GNUTLS_DIG_MD5) < 0) \
175                 SEGFAULT();                                   \
176         } while (0)
177 #define MD5_Final(digest, ctx) \
178         gnutls_hash_deinit(*(ctx),(digest))
179 static inline void
180 MD5_Update(MD5_CTX *ctx, const void *data, size_t length)
181 {
182     gnutls_hash(*ctx, data, length);
183 }
184 
185 #define USE_LIB_CRYPTO_SHA1
186 typedef gnutls_hash_hd_t SHA_CTX;
187 #define SHA1_Init(ctx)                                        \
188         do {                                                  \
189             if (gnutls_hash_init((ctx), GNUTLS_DIG_SHA1) < 0) \
190                 SEGFAULT();                                   \
191         } while (0)
192 #define SHA1_Final(digest, ctx) \
193         gnutls_hash_deinit(*(ctx),(digest))
194 static inline void
195 SHA1_Update(SHA_CTX *ctx, const void *data, size_t length)
196 {
197     gnutls_hash(*ctx, data, length);
198 }
199 
200 #define USE_LIB_CRYPTO_SHA256
201 typedef gnutls_hash_hd_t SHA256_CTX;
202 #define SHA256_Init(ctx)                                        \
203         do {                                                    \
204             if (gnutls_hash_init((ctx), GNUTLS_DIG_SHA256) < 0) \
205                 SEGFAULT();                                     \
206         } while (0)
207 #define SHA256_Final(digest, ctx) \
208         gnutls_hash_deinit(*(ctx),(digest))
209 static inline void
210 SHA256_Update(SHA256_CTX *ctx, const void *data, size_t length)
211 {
212     gnutls_hash(*ctx, data, length);
213 }
214 
215 #endif
216 
217 #endif /* USE_LIB_CRYPTO */
218 
219 
220 #ifdef USE_LIB_CRYPTO_MD5
221 #ifndef MD5_DIGEST_LENGTH
222 #define MD5_DIGEST_LENGTH 16
223 #endif
224 #include "md5.h" /*(for legacy li_MD5_*() name mangling)*/
225 #else
226 #include "md5.h"
227 #endif
228 
229 
230 #ifdef USE_LIB_CRYPTO_SHA1
231 #ifndef SHA_DIGEST_LENGTH
232 #define SHA_DIGEST_LENGTH 20
233 #endif
234 #else
235 #include "algo_sha1.h"
236 #endif
237 
238 
239 #endif /* LI_SYS_CRYPTO_MD_H */
240