1 | /***************************************************************************
|
---|
2 | * _ _ ____ _
|
---|
3 | * Project ___| | | | _ \| |
|
---|
4 | * / __| | | | |_) | |
|
---|
5 | * | (__| |_| | _ <| |___
|
---|
6 | * \___|\___/|_| \_\_____|
|
---|
7 | *
|
---|
8 | * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
|
---|
9 | *
|
---|
10 | * This software is licensed as described in the file COPYING, which
|
---|
11 | * you should have received as part of this distribution. The terms
|
---|
12 | * are also available at https://curl.haxx.se/docs/copyright.html.
|
---|
13 | *
|
---|
14 | * You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
---|
15 | * copies of the Software, and permit persons to whom the Software is
|
---|
16 | * furnished to do so, under the terms of the COPYING file.
|
---|
17 | *
|
---|
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
---|
19 | * KIND, either express or implied.
|
---|
20 | *
|
---|
21 | ***************************************************************************/
|
---|
22 | #include "tool_setup.h"
|
---|
23 |
|
---|
24 | #ifdef USE_METALINK
|
---|
25 |
|
---|
26 | #include <sys/stat.h>
|
---|
27 | #include <stdlib.h>
|
---|
28 |
|
---|
29 | #ifdef HAVE_FCNTL_H
|
---|
30 | # include <fcntl.h>
|
---|
31 | #endif
|
---|
32 |
|
---|
33 | #undef HAVE_NSS_CONTEXT
|
---|
34 |
|
---|
35 | #ifdef USE_OPENSSL
|
---|
36 | # include <openssl/md5.h>
|
---|
37 | # include <openssl/sha.h>
|
---|
38 | #elif defined(USE_GNUTLS_NETTLE)
|
---|
39 | # include <nettle/md5.h>
|
---|
40 | # include <nettle/sha.h>
|
---|
41 | # define MD5_CTX struct md5_ctx
|
---|
42 | # define SHA_CTX struct sha1_ctx
|
---|
43 | # define SHA256_CTX struct sha256_ctx
|
---|
44 | #elif defined(USE_GNUTLS)
|
---|
45 | # include <gcrypt.h>
|
---|
46 | # define MD5_CTX gcry_md_hd_t
|
---|
47 | # define SHA_CTX gcry_md_hd_t
|
---|
48 | # define SHA256_CTX gcry_md_hd_t
|
---|
49 | #elif defined(USE_NSS)
|
---|
50 | # include <nss.h>
|
---|
51 | # include <pk11pub.h>
|
---|
52 | # define MD5_CTX void *
|
---|
53 | # define SHA_CTX void *
|
---|
54 | # define SHA256_CTX void *
|
---|
55 | # define HAVE_NSS_CONTEXT
|
---|
56 | static NSSInitContext *nss_context;
|
---|
57 | #elif defined(USE_POLARSSL)
|
---|
58 | # include <polarssl/md5.h>
|
---|
59 | # include <polarssl/sha1.h>
|
---|
60 | # include <polarssl/sha256.h>
|
---|
61 | # define MD5_CTX md5_context
|
---|
62 | # define SHA_CTX sha1_context
|
---|
63 | # define SHA256_CTX sha256_context
|
---|
64 | #elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
|
---|
65 | (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040)) || \
|
---|
66 | (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
|
---|
67 | (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000))
|
---|
68 | /* For Apple operating systems: CommonCrypto has the functions we need.
|
---|
69 | The library's headers are even backward-compatible with OpenSSL's
|
---|
70 | headers as long as we define COMMON_DIGEST_FOR_OPENSSL first.
|
---|
71 |
|
---|
72 | These functions are available on Tiger and later, as well as iOS 2.0
|
---|
73 | and later. If you're building for an older cat, well, sorry. */
|
---|
74 | # define COMMON_DIGEST_FOR_OPENSSL
|
---|
75 | # include <CommonCrypto/CommonDigest.h>
|
---|
76 | #elif defined(_WIN32)
|
---|
77 | /* For Windows: If no other crypto library is provided, we fallback
|
---|
78 | to the hash functions provided within the Microsoft Windows CryptoAPI */
|
---|
79 | # include <wincrypt.h>
|
---|
80 | /* Custom structure in order to store the required provider and hash handle */
|
---|
81 | struct win32_crypto_hash {
|
---|
82 | HCRYPTPROV hCryptProv;
|
---|
83 | HCRYPTHASH hHash;
|
---|
84 | };
|
---|
85 | /* Custom Microsoft AES Cryptographic Provider defines required for MinGW */
|
---|
86 | # ifndef ALG_SID_SHA_256
|
---|
87 | # define ALG_SID_SHA_256 12
|
---|
88 | # endif
|
---|
89 | # ifndef CALG_SHA_256
|
---|
90 | # define CALG_SHA_256 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_256)
|
---|
91 | # endif
|
---|
92 | # define MD5_CTX struct win32_crypto_hash
|
---|
93 | # define SHA_CTX struct win32_crypto_hash
|
---|
94 | # define SHA256_CTX struct win32_crypto_hash
|
---|
95 | #else
|
---|
96 | # error "Can't compile METALINK support without a crypto library."
|
---|
97 | #endif
|
---|
98 |
|
---|
99 | #define ENABLE_CURLX_PRINTF
|
---|
100 | /* use our own printf() functions */
|
---|
101 | #include "curlx.h"
|
---|
102 |
|
---|
103 | #include "tool_getparam.h"
|
---|
104 | #include "tool_paramhlp.h"
|
---|
105 | #include "tool_cfgable.h"
|
---|
106 | #include "tool_metalink.h"
|
---|
107 | #include "tool_msgs.h"
|
---|
108 |
|
---|
109 | #include "memdebug.h" /* keep this as LAST include */
|
---|
110 |
|
---|
111 | /* Copied from tool_getparam.c */
|
---|
112 | #define GetStr(str,val) do { \
|
---|
113 | if(*(str)) { \
|
---|
114 | free(*(str)); \
|
---|
115 | *(str) = NULL; \
|
---|
116 | } \
|
---|
117 | if((val)) \
|
---|
118 | *(str) = strdup((val)); \
|
---|
119 | if(!(val)) \
|
---|
120 | return PARAM_NO_MEM; \
|
---|
121 | } WHILE_FALSE
|
---|
122 |
|
---|
123 | #if defined(USE_OPENSSL)
|
---|
124 | /* Functions are already defined */
|
---|
125 | #elif defined(USE_GNUTLS_NETTLE)
|
---|
126 |
|
---|
127 | static int MD5_Init(MD5_CTX *ctx)
|
---|
128 | {
|
---|
129 | md5_init(ctx);
|
---|
130 | return 1;
|
---|
131 | }
|
---|
132 |
|
---|
133 | static void MD5_Update(MD5_CTX *ctx,
|
---|
134 | const unsigned char *input,
|
---|
135 | unsigned int inputLen)
|
---|
136 | {
|
---|
137 | md5_update(ctx, inputLen, input);
|
---|
138 | }
|
---|
139 |
|
---|
140 | static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
|
---|
141 | {
|
---|
142 | md5_digest(ctx, 16, digest);
|
---|
143 | }
|
---|
144 |
|
---|
145 | static int SHA1_Init(SHA_CTX *ctx)
|
---|
146 | {
|
---|
147 | sha1_init(ctx);
|
---|
148 | return 1;
|
---|
149 | }
|
---|
150 |
|
---|
151 | static void SHA1_Update(SHA_CTX *ctx,
|
---|
152 | const unsigned char *input,
|
---|
153 | unsigned int inputLen)
|
---|
154 | {
|
---|
155 | sha1_update(ctx, inputLen, input);
|
---|
156 | }
|
---|
157 |
|
---|
158 | static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
|
---|
159 | {
|
---|
160 | sha1_digest(ctx, 20, digest);
|
---|
161 | }
|
---|
162 |
|
---|
163 | static int SHA256_Init(SHA256_CTX *ctx)
|
---|
164 | {
|
---|
165 | sha256_init(ctx);
|
---|
166 | return 1;
|
---|
167 | }
|
---|
168 |
|
---|
169 | static void SHA256_Update(SHA256_CTX *ctx,
|
---|
170 | const unsigned char *input,
|
---|
171 | unsigned int inputLen)
|
---|
172 | {
|
---|
173 | sha256_update(ctx, inputLen, input);
|
---|
174 | }
|
---|
175 |
|
---|
176 | static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
|
---|
177 | {
|
---|
178 | sha256_digest(ctx, 32, digest);
|
---|
179 | }
|
---|
180 |
|
---|
181 | #elif defined(USE_GNUTLS)
|
---|
182 |
|
---|
183 | static int MD5_Init(MD5_CTX *ctx)
|
---|
184 | {
|
---|
185 | gcry_md_open(ctx, GCRY_MD_MD5, 0);
|
---|
186 | return 1;
|
---|
187 | }
|
---|
188 |
|
---|
189 | static void MD5_Update(MD5_CTX *ctx,
|
---|
190 | const unsigned char *input,
|
---|
191 | unsigned int inputLen)
|
---|
192 | {
|
---|
193 | gcry_md_write(*ctx, input, inputLen);
|
---|
194 | }
|
---|
195 |
|
---|
196 | static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
|
---|
197 | {
|
---|
198 | memcpy(digest, gcry_md_read(*ctx, 0), 16);
|
---|
199 | gcry_md_close(*ctx);
|
---|
200 | }
|
---|
201 |
|
---|
202 | static int SHA1_Init(SHA_CTX *ctx)
|
---|
203 | {
|
---|
204 | gcry_md_open(ctx, GCRY_MD_SHA1, 0);
|
---|
205 | return 1;
|
---|
206 | }
|
---|
207 |
|
---|
208 | static void SHA1_Update(SHA_CTX *ctx,
|
---|
209 | const unsigned char *input,
|
---|
210 | unsigned int inputLen)
|
---|
211 | {
|
---|
212 | gcry_md_write(*ctx, input, inputLen);
|
---|
213 | }
|
---|
214 |
|
---|
215 | static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
|
---|
216 | {
|
---|
217 | memcpy(digest, gcry_md_read(*ctx, 0), 20);
|
---|
218 | gcry_md_close(*ctx);
|
---|
219 | }
|
---|
220 |
|
---|
221 | static int SHA256_Init(SHA256_CTX *ctx)
|
---|
222 | {
|
---|
223 | gcry_md_open(ctx, GCRY_MD_SHA256, 0);
|
---|
224 | return 1;
|
---|
225 | }
|
---|
226 |
|
---|
227 | static void SHA256_Update(SHA256_CTX *ctx,
|
---|
228 | const unsigned char *input,
|
---|
229 | unsigned int inputLen)
|
---|
230 | {
|
---|
231 | gcry_md_write(*ctx, input, inputLen);
|
---|
232 | }
|
---|
233 |
|
---|
234 | static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
|
---|
235 | {
|
---|
236 | memcpy(digest, gcry_md_read(*ctx, 0), 32);
|
---|
237 | gcry_md_close(*ctx);
|
---|
238 | }
|
---|
239 |
|
---|
240 | #elif defined(USE_NSS)
|
---|
241 |
|
---|
242 | static int nss_hash_init(void **pctx, SECOidTag hash_alg)
|
---|
243 | {
|
---|
244 | PK11Context *ctx;
|
---|
245 |
|
---|
246 | /* we have to initialize NSS if not initialized alraedy */
|
---|
247 | if(!NSS_IsInitialized() && !nss_context) {
|
---|
248 | static NSSInitParameters params;
|
---|
249 | params.length = sizeof params;
|
---|
250 | nss_context = NSS_InitContext("", "", "", "", ¶ms, NSS_INIT_READONLY
|
---|
251 | | NSS_INIT_NOCERTDB | NSS_INIT_NOMODDB | NSS_INIT_FORCEOPEN
|
---|
252 | | NSS_INIT_NOROOTINIT | NSS_INIT_OPTIMIZESPACE | NSS_INIT_PK11RELOAD);
|
---|
253 | }
|
---|
254 |
|
---|
255 | ctx = PK11_CreateDigestContext(hash_alg);
|
---|
256 | if(!ctx)
|
---|
257 | return /* failure */ 0;
|
---|
258 |
|
---|
259 | if(PK11_DigestBegin(ctx) != SECSuccess) {
|
---|
260 | PK11_DestroyContext(ctx, PR_TRUE);
|
---|
261 | return /* failure */ 0;
|
---|
262 | }
|
---|
263 |
|
---|
264 | *pctx = ctx;
|
---|
265 | return /* success */ 1;
|
---|
266 | }
|
---|
267 |
|
---|
268 | static void nss_hash_final(void **pctx, unsigned char *out, unsigned int len)
|
---|
269 | {
|
---|
270 | PK11Context *ctx = *pctx;
|
---|
271 | unsigned int outlen;
|
---|
272 | PK11_DigestFinal(ctx, out, &outlen, len);
|
---|
273 | PK11_DestroyContext(ctx, PR_TRUE);
|
---|
274 | }
|
---|
275 |
|
---|
276 | static int MD5_Init(MD5_CTX *pctx)
|
---|
277 | {
|
---|
278 | return nss_hash_init(pctx, SEC_OID_MD5);
|
---|
279 | }
|
---|
280 |
|
---|
281 | static void MD5_Update(MD5_CTX *pctx,
|
---|
282 | const unsigned char *input,
|
---|
283 | unsigned int input_len)
|
---|
284 | {
|
---|
285 | PK11_DigestOp(*pctx, input, input_len);
|
---|
286 | }
|
---|
287 |
|
---|
288 | static void MD5_Final(unsigned char digest[16], MD5_CTX *pctx)
|
---|
289 | {
|
---|
290 | nss_hash_final(pctx, digest, 16);
|
---|
291 | }
|
---|
292 |
|
---|
293 | static int SHA1_Init(SHA_CTX *pctx)
|
---|
294 | {
|
---|
295 | return nss_hash_init(pctx, SEC_OID_SHA1);
|
---|
296 | }
|
---|
297 |
|
---|
298 | static void SHA1_Update(SHA_CTX *pctx,
|
---|
299 | const unsigned char *input,
|
---|
300 | unsigned int input_len)
|
---|
301 | {
|
---|
302 | PK11_DigestOp(*pctx, input, input_len);
|
---|
303 | }
|
---|
304 |
|
---|
305 | static void SHA1_Final(unsigned char digest[20], SHA_CTX *pctx)
|
---|
306 | {
|
---|
307 | nss_hash_final(pctx, digest, 20);
|
---|
308 | }
|
---|
309 |
|
---|
310 | static int SHA256_Init(SHA256_CTX *pctx)
|
---|
311 | {
|
---|
312 | return nss_hash_init(pctx, SEC_OID_SHA256);
|
---|
313 | }
|
---|
314 |
|
---|
315 | static void SHA256_Update(SHA256_CTX *pctx,
|
---|
316 | const unsigned char *input,
|
---|
317 | unsigned int input_len)
|
---|
318 | {
|
---|
319 | PK11_DigestOp(*pctx, input, input_len);
|
---|
320 | }
|
---|
321 |
|
---|
322 | static void SHA256_Final(unsigned char digest[32], SHA256_CTX *pctx)
|
---|
323 | {
|
---|
324 | nss_hash_final(pctx, digest, 32);
|
---|
325 | }
|
---|
326 |
|
---|
327 | #elif defined(USE_POLARSSL)
|
---|
328 |
|
---|
329 | static int MD5_Init(MD5_CTX *ctx)
|
---|
330 | {
|
---|
331 | md5_starts(ctx);
|
---|
332 | return 1;
|
---|
333 | }
|
---|
334 |
|
---|
335 | static void MD5_Update(MD5_CTX *ctx,
|
---|
336 | const unsigned char *input,
|
---|
337 | unsigned int inputLen)
|
---|
338 | {
|
---|
339 | md5_update(ctx, input, inputLen);
|
---|
340 | }
|
---|
341 |
|
---|
342 | static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
|
---|
343 | {
|
---|
344 | md5_finish(ctx, digest);
|
---|
345 | }
|
---|
346 |
|
---|
347 | static int SHA1_Init(SHA_CTX *ctx)
|
---|
348 | {
|
---|
349 | sha1_starts(ctx);
|
---|
350 | return 1;
|
---|
351 | }
|
---|
352 |
|
---|
353 | static void SHA1_Update(SHA_CTX *ctx,
|
---|
354 | const unsigned char *input,
|
---|
355 | unsigned int inputLen)
|
---|
356 | {
|
---|
357 | sha1_update(ctx, input, inputLen);
|
---|
358 | }
|
---|
359 |
|
---|
360 | static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
|
---|
361 | {
|
---|
362 | sha1_finish(ctx, digest);
|
---|
363 | }
|
---|
364 |
|
---|
365 | static int SHA256_Init(SHA256_CTX *ctx)
|
---|
366 | {
|
---|
367 | sha256_starts(ctx, 0); /* 0 = sha256 */
|
---|
368 | return 1;
|
---|
369 | }
|
---|
370 |
|
---|
371 | static void SHA256_Update(SHA256_CTX *ctx,
|
---|
372 | const unsigned char *input,
|
---|
373 | unsigned int inputLen)
|
---|
374 | {
|
---|
375 | sha256_update(ctx, input, inputLen);
|
---|
376 | }
|
---|
377 |
|
---|
378 | static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
|
---|
379 | {
|
---|
380 | sha256_finish(ctx, digest);
|
---|
381 | }
|
---|
382 |
|
---|
383 | #elif defined(_WIN32)
|
---|
384 |
|
---|
385 | static void win32_crypto_final(struct win32_crypto_hash *ctx,
|
---|
386 | unsigned char *digest,
|
---|
387 | unsigned int digestLen)
|
---|
388 | {
|
---|
389 | unsigned long length;
|
---|
390 | CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
|
---|
391 | if(length == digestLen)
|
---|
392 | CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0);
|
---|
393 | if(ctx->hHash)
|
---|
394 | CryptDestroyHash(ctx->hHash);
|
---|
395 | if(ctx->hCryptProv)
|
---|
396 | CryptReleaseContext(ctx->hCryptProv, 0);
|
---|
397 | }
|
---|
398 |
|
---|
399 | static int MD5_Init(MD5_CTX *ctx)
|
---|
400 | {
|
---|
401 | if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
|
---|
402 | PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
|
---|
403 | CryptCreateHash(ctx->hCryptProv, CALG_MD5, 0, 0, &ctx->hHash);
|
---|
404 | }
|
---|
405 | return 1;
|
---|
406 | }
|
---|
407 |
|
---|
408 | static void MD5_Update(MD5_CTX *ctx,
|
---|
409 | const unsigned char *input,
|
---|
410 | unsigned int inputLen)
|
---|
411 | {
|
---|
412 | CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
|
---|
413 | }
|
---|
414 |
|
---|
415 | static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
|
---|
416 | {
|
---|
417 | win32_crypto_final(ctx, digest, 16);
|
---|
418 | }
|
---|
419 |
|
---|
420 | static int SHA1_Init(SHA_CTX *ctx)
|
---|
421 | {
|
---|
422 | if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
|
---|
423 | PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
|
---|
424 | CryptCreateHash(ctx->hCryptProv, CALG_SHA1, 0, 0, &ctx->hHash);
|
---|
425 | }
|
---|
426 | return 1;
|
---|
427 | }
|
---|
428 |
|
---|
429 | static void SHA1_Update(SHA_CTX *ctx,
|
---|
430 | const unsigned char *input,
|
---|
431 | unsigned int inputLen)
|
---|
432 | {
|
---|
433 | CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
|
---|
434 | }
|
---|
435 |
|
---|
436 | static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
|
---|
437 | {
|
---|
438 | win32_crypto_final(ctx, digest, 20);
|
---|
439 | }
|
---|
440 |
|
---|
441 | static int SHA256_Init(SHA256_CTX *ctx)
|
---|
442 | {
|
---|
443 | if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
|
---|
444 | PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
|
---|
445 | CryptCreateHash(ctx->hCryptProv, CALG_SHA_256, 0, 0, &ctx->hHash);
|
---|
446 | }
|
---|
447 | return 1;
|
---|
448 | }
|
---|
449 |
|
---|
450 | static void SHA256_Update(SHA256_CTX *ctx,
|
---|
451 | const unsigned char *input,
|
---|
452 | unsigned int inputLen)
|
---|
453 | {
|
---|
454 | CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
|
---|
455 | }
|
---|
456 |
|
---|
457 | static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
|
---|
458 | {
|
---|
459 | win32_crypto_final(ctx, digest, 32);
|
---|
460 | }
|
---|
461 |
|
---|
462 | #endif /* CRYPTO LIBS */
|
---|
463 |
|
---|
464 | const digest_params MD5_DIGEST_PARAMS[] = {
|
---|
465 | {
|
---|
466 | (Curl_digest_init_func) MD5_Init,
|
---|
467 | (Curl_digest_update_func) MD5_Update,
|
---|
468 | (Curl_digest_final_func) MD5_Final,
|
---|
469 | sizeof(MD5_CTX),
|
---|
470 | 16
|
---|
471 | }
|
---|
472 | };
|
---|
473 |
|
---|
474 | const digest_params SHA1_DIGEST_PARAMS[] = {
|
---|
475 | {
|
---|
476 | (Curl_digest_init_func) SHA1_Init,
|
---|
477 | (Curl_digest_update_func) SHA1_Update,
|
---|
478 | (Curl_digest_final_func) SHA1_Final,
|
---|
479 | sizeof(SHA_CTX),
|
---|
480 | 20
|
---|
481 | }
|
---|
482 | };
|
---|
483 |
|
---|
484 | const digest_params SHA256_DIGEST_PARAMS[] = {
|
---|
485 | {
|
---|
486 | (Curl_digest_init_func) SHA256_Init,
|
---|
487 | (Curl_digest_update_func) SHA256_Update,
|
---|
488 | (Curl_digest_final_func) SHA256_Final,
|
---|
489 | sizeof(SHA256_CTX),
|
---|
490 | 32
|
---|
491 | }
|
---|
492 | };
|
---|
493 |
|
---|
494 | static const metalink_digest_def SHA256_DIGEST_DEF[] = {
|
---|
495 | {"sha-256", SHA256_DIGEST_PARAMS}
|
---|
496 | };
|
---|
497 |
|
---|
498 | static const metalink_digest_def SHA1_DIGEST_DEF[] = {
|
---|
499 | {"sha-1", SHA1_DIGEST_PARAMS}
|
---|
500 | };
|
---|
501 |
|
---|
502 | static const metalink_digest_def MD5_DIGEST_DEF[] = {
|
---|
503 | {"md5", MD5_DIGEST_PARAMS}
|
---|
504 | };
|
---|
505 |
|
---|
506 | /*
|
---|
507 | * The alias of supported hash functions in the order by preference
|
---|
508 | * (basically stronger hash comes first). We included "sha-256" and
|
---|
509 | * "sha256". The former is the name defined in the IANA registry named
|
---|
510 | * "Hash Function Textual Names". The latter is widely (and
|
---|
511 | * historically) used in Metalink version 3.
|
---|
512 | */
|
---|
513 | static const metalink_digest_alias digest_aliases[] = {
|
---|
514 | {"sha-256", SHA256_DIGEST_DEF},
|
---|
515 | {"sha256", SHA256_DIGEST_DEF},
|
---|
516 | {"sha-1", SHA1_DIGEST_DEF},
|
---|
517 | {"sha1", SHA1_DIGEST_DEF},
|
---|
518 | {"md5", MD5_DIGEST_DEF},
|
---|
519 | {NULL, NULL}
|
---|
520 | };
|
---|
521 |
|
---|
522 | digest_context *Curl_digest_init(const digest_params *dparams)
|
---|
523 | {
|
---|
524 | digest_context *ctxt;
|
---|
525 |
|
---|
526 | /* Create digest context */
|
---|
527 | ctxt = malloc(sizeof *ctxt);
|
---|
528 |
|
---|
529 | if(!ctxt)
|
---|
530 | return ctxt;
|
---|
531 |
|
---|
532 | ctxt->digest_hashctx = malloc(dparams->digest_ctxtsize);
|
---|
533 |
|
---|
534 | if(!ctxt->digest_hashctx) {
|
---|
535 | free(ctxt);
|
---|
536 | return NULL;
|
---|
537 | }
|
---|
538 |
|
---|
539 | ctxt->digest_hash = dparams;
|
---|
540 |
|
---|
541 | if(dparams->digest_init(ctxt->digest_hashctx) != 1) {
|
---|
542 | free(ctxt->digest_hashctx);
|
---|
543 | free(ctxt);
|
---|
544 | return NULL;
|
---|
545 | }
|
---|
546 |
|
---|
547 | return ctxt;
|
---|
548 | }
|
---|
549 |
|
---|
550 | int Curl_digest_update(digest_context *context,
|
---|
551 | const unsigned char *data,
|
---|
552 | unsigned int len)
|
---|
553 | {
|
---|
554 | (*context->digest_hash->digest_update)(context->digest_hashctx, data, len);
|
---|
555 |
|
---|
556 | return 0;
|
---|
557 | }
|
---|
558 |
|
---|
559 | int Curl_digest_final(digest_context *context, unsigned char *result)
|
---|
560 | {
|
---|
561 | if(result)
|
---|
562 | (*context->digest_hash->digest_final)(result, context->digest_hashctx);
|
---|
563 |
|
---|
564 | free(context->digest_hashctx);
|
---|
565 | free(context);
|
---|
566 |
|
---|
567 | return 0;
|
---|
568 | }
|
---|
569 |
|
---|
570 | static unsigned char hex_to_uint(const char *s)
|
---|
571 | {
|
---|
572 | char buf[3];
|
---|
573 | unsigned long val;
|
---|
574 | buf[0] = s[0];
|
---|
575 | buf[1] = s[1];
|
---|
576 | buf[2] = 0;
|
---|
577 | val = strtoul(buf, NULL, 16);
|
---|
578 | return (unsigned char)(val&0xff);
|
---|
579 | }
|
---|
580 |
|
---|
581 | /*
|
---|
582 | * Check checksum of file denoted by filename. The expected hash value
|
---|
583 | * is given in hex_hash which is hex-encoded string.
|
---|
584 | *
|
---|
585 | * This function returns 1 if it succeeds or one of the following
|
---|
586 | * integers:
|
---|
587 | *
|
---|
588 | * 0:
|
---|
589 | * Checksum didn't match.
|
---|
590 | * -1:
|
---|
591 | * Could not open file; or could not read data from file.
|
---|
592 | * -2:
|
---|
593 | * Hash algorithm not available.
|
---|
594 | */
|
---|
595 | static int check_hash(const char *filename,
|
---|
596 | const metalink_digest_def *digest_def,
|
---|
597 | const unsigned char *digest, FILE *error)
|
---|
598 | {
|
---|
599 | unsigned char *result;
|
---|
600 | digest_context *dctx;
|
---|
601 | int check_ok, flags, fd;
|
---|
602 |
|
---|
603 | flags = O_RDONLY;
|
---|
604 | #ifdef O_BINARY
|
---|
605 | /* O_BINARY is required in order to avoid binary EOF in text mode */
|
---|
606 | flags |= O_BINARY;
|
---|
607 | #endif
|
---|
608 |
|
---|
609 | fd = open(filename, flags);
|
---|
610 | if(fd == -1) {
|
---|
611 | fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
|
---|
612 | digest_def->hash_name, strerror(errno));
|
---|
613 | return -1;
|
---|
614 | }
|
---|
615 |
|
---|
616 | dctx = Curl_digest_init(digest_def->dparams);
|
---|
617 | if(!dctx) {
|
---|
618 | fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
|
---|
619 | digest_def->hash_name, "failed to initialize hash algorithm");
|
---|
620 | close(fd);
|
---|
621 | return -2;
|
---|
622 | }
|
---|
623 |
|
---|
624 | result = malloc(digest_def->dparams->digest_resultlen);
|
---|
625 | if(!result) {
|
---|
626 | close(fd);
|
---|
627 | Curl_digest_final(dctx, NULL);
|
---|
628 | return -1;
|
---|
629 | }
|
---|
630 | while(1) {
|
---|
631 | unsigned char buf[4096];
|
---|
632 | ssize_t len = read(fd, buf, sizeof(buf));
|
---|
633 | if(len == 0) {
|
---|
634 | break;
|
---|
635 | }
|
---|
636 | else if(len == -1) {
|
---|
637 | fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
|
---|
638 | digest_def->hash_name, strerror(errno));
|
---|
639 | Curl_digest_final(dctx, result);
|
---|
640 | close(fd);
|
---|
641 | return -1;
|
---|
642 | }
|
---|
643 | Curl_digest_update(dctx, buf, (unsigned int)len);
|
---|
644 | }
|
---|
645 | Curl_digest_final(dctx, result);
|
---|
646 | check_ok = memcmp(result, digest,
|
---|
647 | digest_def->dparams->digest_resultlen) == 0;
|
---|
648 | /* sha*sum style verdict output */
|
---|
649 | if(check_ok)
|
---|
650 | fprintf(error, "Metalink: validating (%s) [%s] OK\n", filename,
|
---|
651 | digest_def->hash_name);
|
---|
652 | else
|
---|
653 | fprintf(error, "Metalink: validating (%s) [%s] FAILED (digest mismatch)\n",
|
---|
654 | filename, digest_def->hash_name);
|
---|
655 |
|
---|
656 | free(result);
|
---|
657 | close(fd);
|
---|
658 | return check_ok;
|
---|
659 | }
|
---|
660 |
|
---|
661 | int metalink_check_hash(struct GlobalConfig *config,
|
---|
662 | metalinkfile *mlfile,
|
---|
663 | const char *filename)
|
---|
664 | {
|
---|
665 | int rv;
|
---|
666 | fprintf(config->errors, "Metalink: validating (%s)...\n", filename);
|
---|
667 | if(mlfile->checksum == NULL) {
|
---|
668 | fprintf(config->errors,
|
---|
669 | "Metalink: validating (%s) FAILED (digest missing)\n", filename);
|
---|
670 | return -2;
|
---|
671 | }
|
---|
672 | rv = check_hash(filename, mlfile->checksum->digest_def,
|
---|
673 | mlfile->checksum->digest, config->errors);
|
---|
674 | return rv;
|
---|
675 | }
|
---|
676 |
|
---|
677 | static metalink_checksum *new_metalink_checksum_from_hex_digest
|
---|
678 | (const metalink_digest_def *digest_def, const char *hex_digest)
|
---|
679 | {
|
---|
680 | metalink_checksum *chksum;
|
---|
681 | unsigned char *digest;
|
---|
682 | size_t i;
|
---|
683 | size_t len = strlen(hex_digest);
|
---|
684 | digest = malloc(len/2);
|
---|
685 | if(!digest)
|
---|
686 | return 0;
|
---|
687 |
|
---|
688 | for(i = 0; i < len; i += 2) {
|
---|
689 | digest[i/2] = hex_to_uint(hex_digest + i);
|
---|
690 | }
|
---|
691 | chksum = malloc(sizeof(metalink_checksum));
|
---|
692 | if(chksum) {
|
---|
693 | chksum->digest_def = digest_def;
|
---|
694 | chksum->digest = digest;
|
---|
695 | }
|
---|
696 | else
|
---|
697 | free(digest);
|
---|
698 | return chksum;
|
---|
699 | }
|
---|
700 |
|
---|
701 | static metalink_resource *new_metalink_resource(const char *url)
|
---|
702 | {
|
---|
703 | metalink_resource *res;
|
---|
704 | res = malloc(sizeof(metalink_resource));
|
---|
705 | if(res) {
|
---|
706 | res->next = NULL;
|
---|
707 | res->url = strdup(url);
|
---|
708 | if(!res->url) {
|
---|
709 | free(res);
|
---|
710 | return NULL;
|
---|
711 | }
|
---|
712 | }
|
---|
713 | return res;
|
---|
714 | }
|
---|
715 |
|
---|
716 | /* Returns nonzero if hex_digest is properly formatted; that is each
|
---|
717 | letter is in [0-9A-Za-z] and the length of the string equals to the
|
---|
718 | result length of digest * 2. */
|
---|
719 | static int check_hex_digest(const char *hex_digest,
|
---|
720 | const metalink_digest_def *digest_def)
|
---|
721 | {
|
---|
722 | size_t i;
|
---|
723 | for(i = 0; hex_digest[i]; ++i) {
|
---|
724 | char c = hex_digest[i];
|
---|
725 | if(!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') ||
|
---|
726 | ('A' <= c && c <= 'Z'))) {
|
---|
727 | return 0;
|
---|
728 | }
|
---|
729 | }
|
---|
730 | return digest_def->dparams->digest_resultlen * 2 == i;
|
---|
731 | }
|
---|
732 |
|
---|
733 | static metalinkfile *new_metalinkfile(metalink_file_t *fileinfo)
|
---|
734 | {
|
---|
735 | metalinkfile *f;
|
---|
736 | f = (metalinkfile*)malloc(sizeof(metalinkfile));
|
---|
737 | if(!f)
|
---|
738 | return NULL;
|
---|
739 |
|
---|
740 | f->next = NULL;
|
---|
741 | f->filename = strdup(fileinfo->name);
|
---|
742 | if(!f->filename) {
|
---|
743 | free(f);
|
---|
744 | return NULL;
|
---|
745 | }
|
---|
746 | f->checksum = NULL;
|
---|
747 | f->resource = NULL;
|
---|
748 | if(fileinfo->checksums) {
|
---|
749 | const metalink_digest_alias *digest_alias;
|
---|
750 | for(digest_alias = digest_aliases; digest_alias->alias_name;
|
---|
751 | ++digest_alias) {
|
---|
752 | metalink_checksum_t **p;
|
---|
753 | for(p = fileinfo->checksums; *p; ++p) {
|
---|
754 | if(curl_strequal(digest_alias->alias_name, (*p)->type) &&
|
---|
755 | check_hex_digest((*p)->hash, digest_alias->digest_def)) {
|
---|
756 | f->checksum =
|
---|
757 | new_metalink_checksum_from_hex_digest(digest_alias->digest_def,
|
---|
758 | (*p)->hash);
|
---|
759 | break;
|
---|
760 | }
|
---|
761 | }
|
---|
762 | if(f->checksum) {
|
---|
763 | break;
|
---|
764 | }
|
---|
765 | }
|
---|
766 | }
|
---|
767 | if(fileinfo->resources) {
|
---|
768 | metalink_resource_t **p;
|
---|
769 | metalink_resource root, *tail;
|
---|
770 | root.next = NULL;
|
---|
771 | tail = &root;
|
---|
772 | for(p = fileinfo->resources; *p; ++p) {
|
---|
773 | metalink_resource *res;
|
---|
774 | /* Filter by type if it is non-NULL. In Metalink v3, type
|
---|
775 | includes the type of the resource. In curl, we are only
|
---|
776 | interested in HTTP, HTTPS and FTP. In addition to them,
|
---|
777 | Metalink v3 file may contain bittorrent type URL, which
|
---|
778 | points to the BitTorrent metainfo file. We ignore it here.
|
---|
779 | In Metalink v4, type was deprecated and all
|
---|
780 | fileinfo->resources point to the target file. BitTorrent
|
---|
781 | metainfo file URL may be appeared in fileinfo->metaurls.
|
---|
782 | */
|
---|
783 | if((*p)->type == NULL ||
|
---|
784 | curl_strequal((*p)->type, "http") ||
|
---|
785 | curl_strequal((*p)->type, "https") ||
|
---|
786 | curl_strequal((*p)->type, "ftp") ||
|
---|
787 | curl_strequal((*p)->type, "ftps")) {
|
---|
788 | res = new_metalink_resource((*p)->url);
|
---|
789 | if(res) {
|
---|
790 | tail->next = res;
|
---|
791 | tail = res;
|
---|
792 | }
|
---|
793 | else {
|
---|
794 | tail = root.next;
|
---|
795 |
|
---|
796 | /* clean up the linked list */
|
---|
797 | while(tail) {
|
---|
798 | res = tail->next;
|
---|
799 | free(tail->url);
|
---|
800 | free(tail);
|
---|
801 | tail = res;
|
---|
802 | }
|
---|
803 | free(f->filename);
|
---|
804 | free(f);
|
---|
805 | return NULL;
|
---|
806 | }
|
---|
807 | }
|
---|
808 | }
|
---|
809 | f->resource = root.next;
|
---|
810 | }
|
---|
811 | return f;
|
---|
812 | }
|
---|
813 |
|
---|
814 | int parse_metalink(struct OperationConfig *config, struct OutStruct *outs,
|
---|
815 | const char *metalink_url)
|
---|
816 | {
|
---|
817 | metalink_error_t r;
|
---|
818 | metalink_t* metalink;
|
---|
819 | metalink_file_t **files;
|
---|
820 | bool warnings = FALSE;
|
---|
821 |
|
---|
822 | /* metlaink_parse_final deletes outs->metalink_parser */
|
---|
823 | r = metalink_parse_final(outs->metalink_parser, NULL, 0, &metalink);
|
---|
824 | outs->metalink_parser = NULL;
|
---|
825 | if(r != 0) {
|
---|
826 | return -1;
|
---|
827 | }
|
---|
828 | if(metalink->files == NULL) {
|
---|
829 | fprintf(config->global->errors, "Metalink: parsing (%s) WARNING "
|
---|
830 | "(missing or invalid file name)\n",
|
---|
831 | metalink_url);
|
---|
832 | metalink_delete(metalink);
|
---|
833 | return -1;
|
---|
834 | }
|
---|
835 | for(files = metalink->files; *files; ++files) {
|
---|
836 | struct getout *url;
|
---|
837 | /* Skip an entry which has no resource. */
|
---|
838 | if(!(*files)->resources) {
|
---|
839 | fprintf(config->global->errors, "Metalink: parsing (%s) WARNING "
|
---|
840 | "(missing or invalid resource)\n",
|
---|
841 | metalink_url);
|
---|
842 | continue;
|
---|
843 | }
|
---|
844 | if(config->url_get ||
|
---|
845 | ((config->url_get = config->url_list) != NULL)) {
|
---|
846 | /* there's a node here, if it already is filled-in continue to
|
---|
847 | find an "empty" node */
|
---|
848 | while(config->url_get && (config->url_get->flags & GETOUT_URL))
|
---|
849 | config->url_get = config->url_get->next;
|
---|
850 | }
|
---|
851 |
|
---|
852 | /* now there might or might not be an available node to fill in! */
|
---|
853 |
|
---|
854 | if(config->url_get)
|
---|
855 | /* existing node */
|
---|
856 | url = config->url_get;
|
---|
857 | else
|
---|
858 | /* there was no free node, create one! */
|
---|
859 | url = new_getout(config);
|
---|
860 |
|
---|
861 | if(url) {
|
---|
862 | metalinkfile *mlfile = new_metalinkfile(*files);
|
---|
863 | if(!mlfile)
|
---|
864 | break;
|
---|
865 |
|
---|
866 | if(!mlfile->checksum) {
|
---|
867 | warnings = TRUE;
|
---|
868 | fprintf(config->global->errors,
|
---|
869 | "Metalink: parsing (%s) WARNING (digest missing)\n",
|
---|
870 | metalink_url);
|
---|
871 | }
|
---|
872 | /* Set name as url */
|
---|
873 | GetStr(&url->url, mlfile->filename);
|
---|
874 |
|
---|
875 | /* set flag metalink here */
|
---|
876 | url->flags |= GETOUT_URL | GETOUT_METALINK;
|
---|
877 |
|
---|
878 | if(config->metalinkfile_list) {
|
---|
879 | config->metalinkfile_last->next = mlfile;
|
---|
880 | config->metalinkfile_last = mlfile;
|
---|
881 | }
|
---|
882 | else {
|
---|
883 | config->metalinkfile_list = config->metalinkfile_last = mlfile;
|
---|
884 | }
|
---|
885 | }
|
---|
886 | }
|
---|
887 | metalink_delete(metalink);
|
---|
888 | return (warnings) ? -2 : 0;
|
---|
889 | }
|
---|
890 |
|
---|
891 | size_t metalink_write_cb(void *buffer, size_t sz, size_t nmemb,
|
---|
892 | void *userdata)
|
---|
893 | {
|
---|
894 | struct OutStruct *outs = userdata;
|
---|
895 | struct OperationConfig *config = outs->config;
|
---|
896 | int rv;
|
---|
897 |
|
---|
898 | /*
|
---|
899 | * Once that libcurl has called back tool_write_cb() the returned value
|
---|
900 | * is checked against the amount that was intended to be written, if
|
---|
901 | * it does not match then it fails with CURLE_WRITE_ERROR. So at this
|
---|
902 | * point returning a value different from sz*nmemb indicates failure.
|
---|
903 | */
|
---|
904 | const size_t failure = (sz && nmemb) ? 0 : 1;
|
---|
905 |
|
---|
906 | if(!config)
|
---|
907 | return failure;
|
---|
908 |
|
---|
909 | rv = metalink_parse_update(outs->metalink_parser, buffer, sz * nmemb);
|
---|
910 | if(rv == 0)
|
---|
911 | return sz * nmemb;
|
---|
912 | else {
|
---|
913 | fprintf(config->global->errors, "Metalink: parsing FAILED\n");
|
---|
914 | return failure;
|
---|
915 | }
|
---|
916 | }
|
---|
917 |
|
---|
918 | /*
|
---|
919 | * Returns nonzero if content_type includes mediatype.
|
---|
920 | */
|
---|
921 | static int check_content_type(const char *content_type, const char *media_type)
|
---|
922 | {
|
---|
923 | const char *ptr = content_type;
|
---|
924 | size_t media_type_len = strlen(media_type);
|
---|
925 | for(; *ptr && (*ptr == ' ' || *ptr == '\t'); ++ptr);
|
---|
926 | if(!*ptr) {
|
---|
927 | return 0;
|
---|
928 | }
|
---|
929 | return curl_strnequal(ptr, media_type, media_type_len) &&
|
---|
930 | (*(ptr + media_type_len) == '\0' || *(ptr + media_type_len) == ' ' ||
|
---|
931 | *(ptr + media_type_len) == '\t' || *(ptr + media_type_len) == ';');
|
---|
932 | }
|
---|
933 |
|
---|
934 | int check_metalink_content_type(const char *content_type)
|
---|
935 | {
|
---|
936 | return check_content_type(content_type, "application/metalink+xml");
|
---|
937 | }
|
---|
938 |
|
---|
939 | int count_next_metalink_resource(metalinkfile *mlfile)
|
---|
940 | {
|
---|
941 | int count = 0;
|
---|
942 | metalink_resource *res;
|
---|
943 | for(res = mlfile->resource; res; res = res->next, ++count);
|
---|
944 | return count;
|
---|
945 | }
|
---|
946 |
|
---|
947 | static void delete_metalink_checksum(metalink_checksum *chksum)
|
---|
948 | {
|
---|
949 | if(chksum == NULL) {
|
---|
950 | return;
|
---|
951 | }
|
---|
952 | Curl_safefree(chksum->digest);
|
---|
953 | Curl_safefree(chksum);
|
---|
954 | }
|
---|
955 |
|
---|
956 | static void delete_metalink_resource(metalink_resource *res)
|
---|
957 | {
|
---|
958 | if(res == NULL) {
|
---|
959 | return;
|
---|
960 | }
|
---|
961 | Curl_safefree(res->url);
|
---|
962 | Curl_safefree(res);
|
---|
963 | }
|
---|
964 |
|
---|
965 | static void delete_metalinkfile(metalinkfile *mlfile)
|
---|
966 | {
|
---|
967 | metalink_resource *res;
|
---|
968 | if(mlfile == NULL) {
|
---|
969 | return;
|
---|
970 | }
|
---|
971 | Curl_safefree(mlfile->filename);
|
---|
972 | delete_metalink_checksum(mlfile->checksum);
|
---|
973 | for(res = mlfile->resource; res;) {
|
---|
974 | metalink_resource *next;
|
---|
975 | next = res->next;
|
---|
976 | delete_metalink_resource(res);
|
---|
977 | res = next;
|
---|
978 | }
|
---|
979 | Curl_safefree(mlfile);
|
---|
980 | }
|
---|
981 |
|
---|
982 | void clean_metalink(struct OperationConfig *config)
|
---|
983 | {
|
---|
984 | while(config->metalinkfile_list) {
|
---|
985 | metalinkfile *mlfile = config->metalinkfile_list;
|
---|
986 | config->metalinkfile_list = config->metalinkfile_list->next;
|
---|
987 | delete_metalinkfile(mlfile);
|
---|
988 | }
|
---|
989 | config->metalinkfile_last = 0;
|
---|
990 | }
|
---|
991 |
|
---|
992 | void metalink_cleanup(void)
|
---|
993 | {
|
---|
994 | #ifdef HAVE_NSS_CONTEXT
|
---|
995 | if(nss_context) {
|
---|
996 | NSS_ShutdownContext(nss_context);
|
---|
997 | nss_context = NULL;
|
---|
998 | }
|
---|
999 | #endif
|
---|
1000 | }
|
---|
1001 |
|
---|
1002 | #endif /* USE_METALINK */
|
---|