Branch data Line data Source code
1 : : /*-
2 : : * Copyright (c) 2011-2013 Baptiste Daroussin <bapt@FreeBSD.org>
3 : : * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
4 : : * All rights reserved.
5 : : *
6 : : * Redistribution and use in source and binary forms, with or without
7 : : * modification, are permitted provided that the following conditions
8 : : * are met:
9 : : * 1. Redistributions of source code must retain the above copyright
10 : : * notice, this list of conditions and the following disclaimer
11 : : * in this position and unchanged.
12 : : * 2. Redistributions in binary form must reproduce the above copyright
13 : : * notice, this list of conditions and the following disclaimer in the
14 : : * documentation and/or other materials provided with the distribution.
15 : : *
16 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
17 : : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 : : * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
20 : : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 : : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 : : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 : : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 : : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 : : */
27 : :
28 : : #include <sys/stat.h>
29 : : #include <sys/param.h>
30 : :
31 : : #include <fcntl.h>
32 : :
33 : : #include <openssl/err.h>
34 : : #include <openssl/ssl.h>
35 : :
36 : : #include "pkg.h"
37 : : #include "private/event.h"
38 : : #include "private/pkg.h"
39 : :
40 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
41 : : /*
42 : : * This matches the historical usage for pkg. Older versions sign the hex
43 : : * encoding of the SHA256 checksum. If we ever deprecated RSA, this can go
44 : : * away.
45 : : */
46 : : static EVP_MD *md_pkg_sha1;
47 : :
48 : : static EVP_MD *
49 : 16 : EVP_md_pkg_sha1(void)
50 : : {
51 : :
52 [ + + ]: 16 : if (md_pkg_sha1 != NULL)
53 : 8 : return (md_pkg_sha1);
54 : :
55 : 8 : md_pkg_sha1 = EVP_MD_meth_dup(EVP_sha1());
56 [ - + ]: 8 : if (md_pkg_sha1 == NULL)
57 : 0 : return (NULL);
58 : :
59 : 16 : EVP_MD_meth_set_result_size(md_pkg_sha1,
60 : 8 : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX));
61 : 8 : return (md_pkg_sha1);
62 : 16 : }
63 : : #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
64 : :
65 : : struct pkg_key {
66 : : pkg_password_cb *pw_cb;
67 : : char *path;
68 : : EVP_PKEY *key;
69 : : };
70 : :
71 : : static int
72 : 8 : _load_private_key(struct pkg_key *keyinfo)
73 : : {
74 : : FILE *fp;
75 : :
76 [ + - ]: 8 : if ((fp = fopen(keyinfo->path, "re")) == NULL)
77 : 0 : return (EPKG_FATAL);
78 : :
79 : 8 : keyinfo->key = PEM_read_PrivateKey(fp, 0, keyinfo->pw_cb, keyinfo->path);
80 [ - + ]: 8 : if (keyinfo->key == NULL) {
81 : 0 : fclose(fp);
82 : 0 : return (EPKG_FATAL);
83 : : }
84 : :
85 : 8 : fclose(fp);
86 : 8 : return (EPKG_OK);
87 : 8 : }
88 : :
89 : : static EVP_PKEY *
90 : 0 : _load_public_key_buf(unsigned char *cert, int certlen)
91 : : {
92 : : EVP_PKEY *pkey;
93 : : BIO *bp;
94 : : char errbuf[1024];
95 : :
96 : 0 : bp = BIO_new_mem_buf((void *)cert, certlen);
97 [ # # ]: 0 : if (bp == NULL) {
98 : 0 : pkg_emit_error("error allocating public key bio: %s",
99 : 0 : ERR_error_string(ERR_get_error(), errbuf));
100 : 0 : return (NULL);
101 : : }
102 : :
103 : 0 : pkey = PEM_read_bio_PUBKEY(bp, NULL, NULL, NULL);
104 [ # # ]: 0 : if (pkey == NULL) {
105 : 0 : pkg_emit_error("error reading public key: %s",
106 : 0 : ERR_error_string(ERR_get_error(), errbuf));
107 : 0 : BIO_free(bp);
108 : 0 : return (NULL);
109 : : }
110 : :
111 : 0 : BIO_free(bp);
112 : 0 : return (pkey);
113 : 0 : }
114 : :
115 : : struct rsa_verify_cbdata {
116 : : unsigned char *key;
117 : : size_t keylen;
118 : : unsigned char *sig;
119 : : size_t siglen;
120 : : };
121 : :
122 : : static int
123 : 0 : rsa_verify_cert_cb(int fd, void *ud)
124 : : {
125 : 0 : struct rsa_verify_cbdata *cbdata = ud;
126 : : char *sha256;
127 : : char *hash;
128 : : char errbuf[1024];
129 : 0 : EVP_PKEY *pkey = NULL;
130 : : EVP_PKEY_CTX *ctx;
131 : : int ret;
132 : :
133 : 0 : sha256 = pkg_checksum_fd(fd, PKG_HASH_TYPE_SHA256_HEX);
134 [ # # ]: 0 : if (sha256 == NULL)
135 : 0 : return (EPKG_FATAL);
136 : :
137 : 0 : hash = pkg_checksum_data(sha256, strlen(sha256),
138 : : PKG_HASH_TYPE_SHA256_RAW);
139 : 0 : free(sha256);
140 : :
141 : 0 : pkey = _load_public_key_buf(cbdata->key, cbdata->keylen);
142 [ # # ]: 0 : if (pkey == NULL) {
143 : 0 : free(hash);
144 : 0 : return (EPKG_FATAL);
145 : : }
146 : :
147 [ # # ]: 0 : if (EVP_PKEY_id(pkey) != EVP_PKEY_RSA) {
148 : 0 : EVP_PKEY_free(pkey);
149 : 0 : free(hash);
150 : 0 : return (EPKG_FATAL);
151 : : }
152 : :
153 : 0 : ctx = EVP_PKEY_CTX_new(pkey, NULL);
154 [ # # ]: 0 : if (ctx == NULL) {
155 : 0 : EVP_PKEY_free(pkey);
156 : 0 : free(hash);
157 : 0 : return (EPKG_FATAL);
158 : : }
159 : :
160 [ # # ]: 0 : if (EVP_PKEY_verify_init(ctx) <= 0) {
161 : 0 : EVP_PKEY_CTX_free(ctx);
162 : 0 : EVP_PKEY_free(pkey);
163 : 0 : free(hash);
164 : 0 : return (EPKG_FATAL);
165 : : }
166 : :
167 [ # # ]: 0 : if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0) {
168 : 0 : EVP_PKEY_CTX_free(ctx);
169 : 0 : EVP_PKEY_free(pkey);
170 : 0 : free(hash);
171 : 0 : return (EPKG_FATAL);
172 : : }
173 : :
174 [ # # ]: 0 : if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0) {
175 : 0 : EVP_PKEY_CTX_free(ctx);
176 : 0 : EVP_PKEY_free(pkey);
177 : 0 : free(hash);
178 : 0 : return (EPKG_FATAL);
179 : : }
180 : :
181 : 0 : ret = EVP_PKEY_verify(ctx, cbdata->sig, cbdata->siglen, hash,
182 : 0 : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_RAW));
183 : 0 : free(hash);
184 [ # # ]: 0 : if (ret <= 0) {
185 [ # # ]: 0 : if (ret < 0)
186 : 0 : pkg_emit_error("rsa verify failed: %s",
187 : 0 : ERR_error_string(ERR_get_error(), errbuf));
188 : : else
189 : 0 : pkg_emit_error("rsa signature verification failure");
190 : 0 : EVP_PKEY_CTX_free(ctx);
191 : 0 : EVP_PKEY_free(pkey);
192 : 0 : return (EPKG_FATAL);
193 : : }
194 : :
195 : 0 : EVP_PKEY_CTX_free(ctx);
196 : 0 : EVP_PKEY_free(pkey);
197 : :
198 : 0 : return (EPKG_OK);
199 : 0 : }
200 : :
201 : : int
202 : 8 : rsa_verify_cert(unsigned char *key, int keylen,
203 : : unsigned char *sig, int siglen, int fd)
204 : : {
205 : : int ret;
206 : 8 : bool need_close = false;
207 : : struct rsa_verify_cbdata cbdata;
208 : :
209 : 8 : (void)lseek(fd, 0, SEEK_SET);
210 : :
211 : 8 : cbdata.key = key;
212 : 8 : cbdata.keylen = keylen;
213 : 8 : cbdata.sig = sig;
214 : 8 : cbdata.siglen = siglen;
215 : :
216 : 8 : SSL_load_error_strings();
217 : 8 : OpenSSL_add_all_algorithms();
218 : 8 : OpenSSL_add_all_ciphers();
219 : :
220 : 8 : ret = pkg_emit_sandbox_call(rsa_verify_cert_cb, fd, &cbdata);
221 [ + - ]: 8 : if (need_close)
222 : 0 : close(fd);
223 : :
224 : 8 : return (ret);
225 : : }
226 : :
227 : : static int
228 : 0 : rsa_verify_cb(int fd, void *ud)
229 : : {
230 : 0 : struct rsa_verify_cbdata *cbdata = ud;
231 : : char *sha256;
232 : : char errbuf[1024];
233 : 0 : EVP_PKEY *pkey = NULL;
234 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
235 : : EVP_PKEY_CTX *ctx;
236 : : #else
237 : : RSA *rsa;
238 : : #endif
239 : : int ret;
240 : :
241 : 0 : sha256 = pkg_checksum_fd(fd, PKG_HASH_TYPE_SHA256_HEX);
242 [ # # ]: 0 : if (sha256 == NULL)
243 : 0 : return (EPKG_FATAL);
244 : :
245 : 0 : pkey = _load_public_key_buf(cbdata->key, cbdata->keylen);
246 [ # # ]: 0 : if (pkey == NULL) {
247 : 0 : free(sha256);
248 : 0 : return (EPKG_FATAL);
249 : : }
250 : :
251 [ # # ]: 0 : if (EVP_PKEY_id(pkey) != EVP_PKEY_RSA) {
252 : 0 : EVP_PKEY_free(pkey);
253 : 0 : free(sha256);
254 : 0 : return (EPKG_FATAL);
255 : : }
256 : :
257 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
258 : 0 : ctx = EVP_PKEY_CTX_new(pkey, NULL);
259 [ # # ]: 0 : if (ctx == NULL) {
260 : 0 : EVP_PKEY_free(pkey);
261 : 0 : free(sha256);
262 : 0 : return (EPKG_FATAL);
263 : : }
264 : :
265 [ # # ]: 0 : if (EVP_PKEY_verify_init(ctx) <= 0) {
266 : 0 : EVP_PKEY_CTX_free(ctx);
267 : 0 : EVP_PKEY_free(pkey);
268 : 0 : free(sha256);
269 : 0 : return (EPKG_FATAL);
270 : : }
271 : :
272 [ # # ]: 0 : if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0) {
273 : 0 : EVP_PKEY_CTX_free(ctx);
274 : 0 : EVP_PKEY_free(pkey);
275 : 0 : free(sha256);
276 : 0 : return (EPKG_FATAL);
277 : : }
278 : :
279 [ # # ]: 0 : if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_md_pkg_sha1()) <= 0) {
280 : 0 : EVP_PKEY_CTX_free(ctx);
281 : 0 : EVP_PKEY_free(pkey);
282 : 0 : free(sha256);
283 : 0 : return (EPKG_FATAL);
284 : : }
285 : :
286 : 0 : ret = EVP_PKEY_verify(ctx, cbdata->sig, cbdata->siglen, sha256,
287 : 0 : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX));
288 : : #else
289 : : rsa = EVP_PKEY_get1_RSA(pkey);
290 : :
291 : : ret = RSA_verify(NID_sha1, sha256,
292 : : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX), cbdata->sig,
293 : : cbdata->siglen, rsa);
294 : : #endif
295 : 0 : free(sha256);
296 [ # # ]: 0 : if (ret <= 0) {
297 [ # # ]: 0 : if (ret < 0)
298 : 0 : pkg_emit_error("%s: %s", cbdata->key,
299 : 0 : ERR_error_string(ERR_get_error(), errbuf));
300 : : else
301 : 0 : pkg_emit_error("%s: rsa signature verification failure",
302 : 0 : cbdata->key);
303 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
304 : 0 : EVP_PKEY_CTX_free(ctx);
305 : : #else
306 : : RSA_free(rsa);
307 : : #endif
308 : 0 : EVP_PKEY_free(pkey);
309 : 0 : return (EPKG_FATAL);
310 : : }
311 : :
312 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
313 : 0 : EVP_PKEY_CTX_free(ctx);
314 : : #else
315 : : RSA_free(rsa);
316 : : #endif
317 : 0 : EVP_PKEY_free(pkey);
318 : :
319 : 0 : return (EPKG_OK);
320 : 0 : }
321 : :
322 : : int
323 : 8 : rsa_verify(const char *key, unsigned char *sig, unsigned int sig_len, int fd)
324 : : {
325 : : int ret;
326 : 8 : bool need_close = false;
327 : : struct rsa_verify_cbdata cbdata;
328 : : char *key_buf;
329 : : off_t key_len;
330 : :
331 [ - + ]: 8 : if (file_to_buffer(key, (char**)&key_buf, &key_len) != EPKG_OK) {
332 : 0 : pkg_emit_errno("rsa_verify", "cannot read key");
333 : 0 : return (EPKG_FATAL);
334 : : }
335 : :
336 : 8 : (void)lseek(fd, 0, SEEK_SET);
337 : :
338 : 8 : cbdata.key = key_buf;
339 : 8 : cbdata.keylen = key_len;
340 : 8 : cbdata.sig = sig;
341 : 8 : cbdata.siglen = sig_len;
342 : :
343 : 8 : SSL_load_error_strings();
344 : 8 : OpenSSL_add_all_algorithms();
345 : 8 : OpenSSL_add_all_ciphers();
346 : :
347 : 8 : ret = pkg_emit_sandbox_call(rsa_verify_cb, fd, &cbdata);
348 [ + - ]: 8 : if (need_close)
349 : 0 : close(fd);
350 : :
351 : 8 : free(key_buf);
352 : :
353 : 8 : return (ret);
354 : 8 : }
355 : :
356 : : int
357 : 16 : rsa_sign(char *path, struct pkg_key *keyinfo, unsigned char **sigret,
358 : : unsigned int *osiglen)
359 : : {
360 : : char errbuf[1024];
361 : 16 : int max_len = 0, ret;
362 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
363 : : EVP_PKEY_CTX *ctx;
364 : : size_t siglen;
365 : : #else
366 : : RSA *rsa;
367 : : #endif
368 : : char *sha256;
369 : :
370 [ + - ]: 16 : if (access(keyinfo->path, R_OK) == -1) {
371 : 0 : pkg_emit_errno("access", keyinfo->path);
372 : 0 : return (EPKG_FATAL);
373 : : }
374 : :
375 [ + + + - ]: 16 : if (keyinfo->key == NULL && _load_private_key(keyinfo) != EPKG_OK) {
376 : 0 : pkg_emit_error("can't load key from %s", keyinfo->path);
377 : 0 : return (EPKG_FATAL);
378 : : }
379 : :
380 : 16 : max_len = EVP_PKEY_size(keyinfo->key);
381 : 16 : *sigret = xcalloc(1, max_len + 1);
382 : :
383 : 16 : sha256 = pkg_checksum_file(path, PKG_HASH_TYPE_SHA256_HEX);
384 [ + - ]: 16 : if (sha256 == NULL)
385 : 0 : return (EPKG_FATAL);
386 : :
387 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
388 : 16 : ctx = EVP_PKEY_CTX_new(keyinfo->key, NULL);
389 [ + - ]: 16 : if (ctx == NULL) {
390 : 0 : free(sha256);
391 : 0 : return (EPKG_FATAL);
392 : : }
393 : :
394 [ - + ]: 16 : if (EVP_PKEY_sign_init(ctx) <= 0) {
395 : 0 : EVP_PKEY_CTX_free(ctx);
396 : 0 : free(sha256);
397 : 0 : return (EPKG_FATAL);
398 : : }
399 : :
400 [ - + ]: 16 : if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0) {
401 : 0 : EVP_PKEY_CTX_free(ctx);
402 : 0 : free(sha256);
403 : 0 : return (EPKG_FATAL);
404 : : }
405 : :
406 [ - + ]: 16 : if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_md_pkg_sha1()) <= 0) {
407 : 0 : EVP_PKEY_CTX_free(ctx);
408 : 0 : free(sha256);
409 : 0 : return (EPKG_FATAL);
410 : : }
411 : :
412 : 16 : siglen = max_len;
413 : 32 : ret = EVP_PKEY_sign(ctx, *sigret, &siglen, sha256,
414 : 16 : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX));
415 : : #else
416 : : rsa = EVP_PKEY_get1_RSA(keyinfo->key);
417 : :
418 : : ret = RSA_sign(NID_sha1, sha256,
419 : : pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX),
420 : : *sigret, osiglen, rsa);
421 : : #endif
422 : 16 : free(sha256);
423 [ - + ]: 16 : if (ret <= 0) {
424 : 0 : pkg_emit_error("%s: %s", keyinfo->path,
425 : 0 : ERR_error_string(ERR_get_error(), errbuf));
426 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
427 : 0 : EVP_PKEY_CTX_free(ctx);
428 : : #else
429 : : RSA_free(rsa);
430 : : #endif
431 : 0 : return (EPKG_FATAL);
432 : : }
433 : :
434 : : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
435 [ + - ]: 16 : assert(siglen <= INT_MAX);
436 : 16 : *osiglen = siglen;
437 : 16 : EVP_PKEY_CTX_free(ctx);
438 : : #else
439 : : RSA_free(rsa);
440 : : #endif
441 : :
442 : 16 : return (EPKG_OK);
443 : 16 : }
444 : :
445 : : int
446 : 8 : rsa_new(struct pkg_key **keyinfo, pkg_password_cb *cb, char *path)
447 : : {
448 [ + - ]: 8 : assert(*keyinfo == NULL);
449 : :
450 : 8 : *keyinfo = xcalloc(1, sizeof(struct pkg_key));
451 : 8 : (*keyinfo)->path = path;
452 : 8 : (*keyinfo)->pw_cb = cb;
453 : :
454 : 8 : SSL_load_error_strings();
455 : :
456 : 8 : OpenSSL_add_all_algorithms();
457 : 8 : OpenSSL_add_all_ciphers();
458 : :
459 : 8 : return (EPKG_OK);
460 : : }
461 : :
462 : : void
463 : 277 : rsa_free(struct pkg_key *keyinfo)
464 : : {
465 [ + + ]: 277 : if (keyinfo == NULL)
466 : 269 : return;
467 : :
468 [ - + ]: 8 : if (keyinfo->key != NULL)
469 : 8 : EVP_PKEY_free(keyinfo->key);
470 : :
471 : 8 : free(keyinfo);
472 [ - + ]: 8 : ERR_free_strings();
473 : 277 : }
474 : :
|
