Line data Source code
1 : /* tls_openssl.c
2 : ** strophe XMPP client library -- TLS abstraction openssl impl.
3 : **
4 : ** Copyright (C) 2005-008 Collecta, Inc.
5 : **
6 : ** This software is provided AS-IS with no warranty, either express
7 : ** or implied.
8 : **
9 : ** This program is dual licensed under the MIT and GPLv3 licenses.
10 : */
11 :
12 : /** @file
13 : * TLS implementation with OpenSSL.
14 : */
15 :
16 : #include <errno.h> /* EINTR */
17 : #include <string.h>
18 :
19 : #ifndef _WIN32
20 : #include <sys/select.h>
21 : #else
22 : #include <winsock2.h>
23 : #endif
24 :
25 : #include <openssl/ssl.h>
26 : #include <openssl/err.h>
27 : #include <openssl/opensslv.h>
28 : #include <openssl/x509v3.h>
29 : #include <openssl/pkcs12.h>
30 :
31 : #include "common.h"
32 : #include "tls.h"
33 : #include "sock.h"
34 :
35 : /*
36 : * Redefine OPENSSL_VERSION_NUMBER for LibreSSL.
37 : * LibreSSL and OpenSSL use different and incompatible version schemes. Solve
38 : * this issue in the way how nginx project did.
39 : */
40 : #if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
41 : #undef OPENSSL_VERSION_NUMBER
42 : #if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
43 : #define OPENSSL_VERSION_NUMBER 0x1010000fL
44 : #elif (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
45 : #define OPENSSL_VERSION_NUMBER 0x1000200fL
46 : #else
47 : #define OPENSSL_VERSION_NUMBER 0x1000107fL
48 : #endif
49 : #endif
50 :
51 : #if OPENSSL_VERSION_NUMBER < 0x30000000L
52 : #define STROPHE_ERR_func_error_string(e) ERR_func_error_string(e)
53 : #else
54 : #define STROPHE_ERR_func_error_string(e) ""
55 : #endif
56 :
57 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
58 : static const unsigned char *ASN1_STRING_get0_data(ASN1_STRING *asn1)
59 : {
60 : return ASN1_STRING_data(asn1);
61 : }
62 : #endif
63 :
64 : #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined LIBRESSL_VERSION_NUMBER
65 : static int SSL_CTX_use_cert_and_key(SSL_CTX *ctx,
66 : X509 *x509,
67 : EVP_PKEY *privatekey,
68 : STACK_OF(X509) * chain,
69 : int override)
70 : {
71 : UNUSED(override);
72 : if (!ctx)
73 : return 0;
74 : if (x509 && !SSL_CTX_use_certificate(ctx, x509))
75 : return 0;
76 : if (privatekey && !SSL_CTX_use_PrivateKey(ctx, privatekey))
77 : return 0;
78 : #ifdef SSL_CTX_set1_chain
79 : if (chain && !SSL_CTX_set1_chain(ctx, chain))
80 : return 0;
81 : #else
82 : UNUSED(chain);
83 : #endif
84 : return 1;
85 : }
86 : #endif
87 :
88 : #if OPENSSL_VERSION_NUMBER < 0x10000000L
89 : static int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
90 : ASN1_OBJECT **poid,
91 : ASN1_TYPE **pvalue)
92 : {
93 : if (gen->type != GEN_OTHERNAME)
94 : return 0;
95 : if (poid)
96 : *poid = gen->d.otherName->type_id;
97 : if (pvalue)
98 : *pvalue = gen->d.otherName->value;
99 : return 1;
100 : }
101 : #endif
102 :
103 : struct _tls {
104 : xmpp_ctx_t *ctx;
105 : sock_t sock;
106 : SSL_CTX *ssl_ctx;
107 : SSL *ssl;
108 : X509 *client_cert;
109 : int lasterror;
110 : };
111 :
112 : enum {
113 : TLS_SHUTDOWN_MAX_RETRIES = 10,
114 : TLS_TIMEOUT_SEC = 0,
115 : TLS_TIMEOUT_USEC = 100000,
116 : };
117 :
118 : static void _tls_sock_wait(tls_t *tls, int error);
119 : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size);
120 : static void _tls_set_error(tls_t *tls, int error);
121 : static void _tls_log_error(xmpp_ctx_t *ctx);
122 : static void _tls_dump_cert_info(tls_t *tls);
123 : static X509 *_tls_cert_read(xmpp_conn_t *conn);
124 : static X509 *
125 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca);
126 : static int _tls_xaddr_nid(void);
127 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res);
128 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res);
129 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn);
130 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert);
131 :
132 : #define TLS_ERROR_STR(error, table) \
133 : _tls_error_str(error, table, ARRAY_SIZE(table))
134 :
135 : #define TLS_ERROR_FIELD(x) [x] = #x
136 : const char *tls_errors[] = {
137 : TLS_ERROR_FIELD(SSL_ERROR_NONE),
138 : TLS_ERROR_FIELD(SSL_ERROR_SSL),
139 : TLS_ERROR_FIELD(SSL_ERROR_WANT_READ),
140 : TLS_ERROR_FIELD(SSL_ERROR_WANT_WRITE),
141 : TLS_ERROR_FIELD(SSL_ERROR_WANT_X509_LOOKUP),
142 : TLS_ERROR_FIELD(SSL_ERROR_SYSCALL),
143 : TLS_ERROR_FIELD(SSL_ERROR_ZERO_RETURN),
144 : TLS_ERROR_FIELD(SSL_ERROR_WANT_CONNECT),
145 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ACCEPT),
146 : #ifndef LIBRESSL_VERSION_NUMBER
147 : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
148 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC),
149 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC_JOB),
150 : #endif
151 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
152 : TLS_ERROR_FIELD(SSL_ERROR_WANT_CLIENT_HELLO_CB),
153 : #endif
154 : #endif /* !LIBRESSL_VERSION_NUMBER */
155 : };
156 : const char *cert_errors[] = {
157 : TLS_ERROR_FIELD(X509_V_OK),
158 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
159 : TLS_ERROR_FIELD(X509_V_ERR_UNSPECIFIED),
160 : #endif
161 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT),
162 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL),
163 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE),
164 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE),
165 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY),
166 : TLS_ERROR_FIELD(X509_V_ERR_CERT_SIGNATURE_FAILURE),
167 : TLS_ERROR_FIELD(X509_V_ERR_CRL_SIGNATURE_FAILURE),
168 : TLS_ERROR_FIELD(X509_V_ERR_CERT_NOT_YET_VALID),
169 : TLS_ERROR_FIELD(X509_V_ERR_CERT_HAS_EXPIRED),
170 : TLS_ERROR_FIELD(X509_V_ERR_CRL_NOT_YET_VALID),
171 : TLS_ERROR_FIELD(X509_V_ERR_CRL_HAS_EXPIRED),
172 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD),
173 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD),
174 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD),
175 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD),
176 : TLS_ERROR_FIELD(X509_V_ERR_OUT_OF_MEM),
177 : TLS_ERROR_FIELD(X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT),
178 : TLS_ERROR_FIELD(X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN),
179 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY),
180 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE),
181 : TLS_ERROR_FIELD(X509_V_ERR_CERT_CHAIN_TOO_LONG),
182 : TLS_ERROR_FIELD(X509_V_ERR_CERT_REVOKED),
183 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_CA),
184 : TLS_ERROR_FIELD(X509_V_ERR_PATH_LENGTH_EXCEEDED),
185 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_PURPOSE),
186 : TLS_ERROR_FIELD(X509_V_ERR_CERT_UNTRUSTED),
187 : TLS_ERROR_FIELD(X509_V_ERR_CERT_REJECTED),
188 : TLS_ERROR_FIELD(X509_V_ERR_SUBJECT_ISSUER_MISMATCH),
189 : TLS_ERROR_FIELD(X509_V_ERR_AKID_SKID_MISMATCH),
190 : TLS_ERROR_FIELD(X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH),
191 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CERTSIGN),
192 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER),
193 : TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION),
194 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CRL_SIGN),
195 : TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION),
196 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_NON_CA),
197 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED),
198 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE),
199 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED),
200 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_EXTENSION),
201 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_POLICY_EXTENSION),
202 : TLS_ERROR_FIELD(X509_V_ERR_NO_EXPLICIT_POLICY),
203 : TLS_ERROR_FIELD(X509_V_ERR_APPLICATION_VERIFICATION),
204 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
205 : TLS_ERROR_FIELD(X509_V_ERR_DIFFERENT_CRL_SCOPE),
206 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE),
207 : TLS_ERROR_FIELD(X509_V_ERR_UNNESTED_RESOURCE),
208 : TLS_ERROR_FIELD(X509_V_ERR_PERMITTED_VIOLATION),
209 : TLS_ERROR_FIELD(X509_V_ERR_EXCLUDED_VIOLATION),
210 : TLS_ERROR_FIELD(X509_V_ERR_SUBTREE_MINMAX),
211 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE),
212 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX),
213 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_NAME_SYNTAX),
214 : TLS_ERROR_FIELD(X509_V_ERR_CRL_PATH_VALIDATION_ERROR),
215 : #ifndef LIBRESSL_VERSION_NUMBER
216 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_VERSION),
217 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_ALGORITHM),
218 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_CURVE),
219 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM),
220 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED),
221 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256),
222 : #endif /* !LIBRESSL_VERSION_NUMBER */
223 : TLS_ERROR_FIELD(X509_V_ERR_HOSTNAME_MISMATCH),
224 : TLS_ERROR_FIELD(X509_V_ERR_EMAIL_MISMATCH),
225 : TLS_ERROR_FIELD(X509_V_ERR_IP_ADDRESS_MISMATCH),
226 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
227 : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
228 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_CALL),
229 : TLS_ERROR_FIELD(X509_V_ERR_STORE_LOOKUP),
230 : #ifndef LIBRESSL_VERSION_NUMBER
231 : TLS_ERROR_FIELD(X509_V_ERR_PATH_LOOP),
232 : TLS_ERROR_FIELD(X509_V_ERR_DANE_NO_MATCH),
233 : TLS_ERROR_FIELD(X509_V_ERR_EE_KEY_TOO_SMALL),
234 : TLS_ERROR_FIELD(X509_V_ERR_CA_KEY_TOO_SMALL),
235 : TLS_ERROR_FIELD(X509_V_ERR_CA_MD_TOO_WEAK),
236 : TLS_ERROR_FIELD(X509_V_ERR_NO_VALID_SCTS),
237 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION),
238 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
239 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_NEEDED),
240 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_FAILED),
241 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_CERT_UNKNOWN),
242 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10101000L */
243 : #endif /* !LIBRESSL_VERSION_NUMBER */
244 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
245 : };
246 : #undef TLS_ERROR_FIELD
247 :
248 2 : void tls_initialize(void)
249 : {
250 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
251 : SSL_library_init();
252 : SSL_load_error_strings();
253 : #else
254 2 : OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL);
255 : #endif
256 : /* init xmppAddr OID */
257 2 : _tls_xaddr_nid();
258 2 : }
259 :
260 2 : void tls_shutdown(void)
261 : {
262 : /*
263 : * FIXME: Don't free global tables, program or other libraries may use
264 : * openssl after libstrophe finalization. Maybe better leak some fixed
265 : * memory rather than cause random crashes of the main program.
266 : */
267 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
268 : OBJ_cleanup();
269 : ERR_free_strings();
270 : EVP_cleanup();
271 : CRYPTO_cleanup_all_ex_data();
272 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
273 : SSL_COMP_free_compression_methods();
274 : #endif
275 : #if OPENSSL_VERSION_NUMBER < 0x10000000L
276 : ERR_remove_state(0);
277 : #else
278 : ERR_remove_thread_state(NULL);
279 : #endif
280 : #endif
281 2 : }
282 :
283 0 : int tls_error(tls_t *tls)
284 : {
285 0 : return tls->lasterror;
286 : }
287 :
288 : /** Search through the SubjectAlternativeNames and return the next
289 : * id-on-xmppAddr element starting from `n`.
290 : */
291 24 : char *tls_id_on_xmppaddr(xmpp_conn_t *conn, unsigned int n)
292 : {
293 24 : char *ret = NULL;
294 24 : int i, j;
295 24 : GENERAL_NAMES *names = _tls_conn_get_names(conn);
296 24 : if (!names) {
297 0 : _tls_log_error(conn->ctx);
298 0 : return NULL;
299 : }
300 24 : int num_names = sk_GENERAL_NAME_num(names);
301 104 : for (i = j = 0; i < num_names; ++i) {
302 72 : char *res;
303 72 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
304 72 : if (name == NULL)
305 : break;
306 72 : if (_tls_xmppaddr_to_string(name, &res))
307 32 : continue;
308 40 : if (j == (int)n) {
309 16 : strophe_debug(conn->ctx, "tls",
310 : "extracted jid %s from id-on-xmppAddr", res);
311 16 : ret = strophe_strdup(conn->ctx, res);
312 16 : OPENSSL_free(res);
313 : break;
314 : }
315 24 : j++;
316 24 : OPENSSL_free(res);
317 : }
318 24 : GENERAL_NAMES_free(names);
319 24 : return ret;
320 : }
321 :
322 8 : unsigned int tls_id_on_xmppaddr_num(xmpp_conn_t *conn)
323 : {
324 8 : unsigned int ret = 0;
325 8 : GENERAL_NAMES *names = _tls_conn_get_names(conn);
326 8 : if (!names) {
327 0 : _tls_log_error(conn->ctx);
328 0 : return 0;
329 : }
330 8 : int j, num_names = sk_GENERAL_NAME_num(names);
331 48 : for (j = 0; j < num_names; ++j) {
332 32 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
333 32 : if (_tls_xmppaddr_to_string(name, NULL))
334 16 : continue;
335 16 : ret++;
336 : }
337 8 : GENERAL_NAMES_free(names);
338 8 : return ret;
339 : }
340 :
341 0 : static int _convert_ASN1TIME(ASN1_TIME *ansi_time, char *buf, size_t len)
342 : {
343 0 : BIO *bio = BIO_new(BIO_s_mem());
344 0 : int rc = ASN1_TIME_print(bio, ansi_time);
345 0 : if (rc <= 0) {
346 0 : BIO_free(bio);
347 0 : return 0;
348 : }
349 0 : rc = BIO_gets(bio, buf, len);
350 0 : if (rc <= 0) {
351 0 : BIO_free(bio);
352 0 : return 0;
353 : }
354 0 : BIO_free(bio);
355 0 : return 1;
356 : }
357 :
358 0 : static char *_asn1_time_to_str(const xmpp_ctx_t *ctx, ASN1_TIME *t)
359 : {
360 0 : char buf[128];
361 0 : int res = _convert_ASN1TIME(t, buf, sizeof(buf));
362 0 : if (res) {
363 0 : return strophe_strdup(ctx, buf);
364 : }
365 : return NULL;
366 : }
367 :
368 : static char *
369 0 : _get_fingerprint(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
370 : {
371 0 : unsigned char buf[EVP_MAX_MD_SIZE];
372 0 : unsigned int len;
373 0 : const EVP_MD *digest;
374 0 : switch (el) {
375 0 : case XMPP_CERT_FINGERPRINT_SHA1:
376 0 : digest = EVP_sha1();
377 : break;
378 0 : case XMPP_CERT_FINGERPRINT_SHA256:
379 0 : digest = EVP_sha256();
380 : break;
381 : default:
382 0 : return NULL;
383 : }
384 0 : if (X509_digest(err_cert, digest, buf, &len) != 0) {
385 0 : char fingerprint[4 * EVP_MAX_MD_SIZE];
386 0 : hex_encode(fingerprint, buf, len);
387 0 : return strophe_strdup(ctx, fingerprint);
388 : }
389 : return NULL;
390 : }
391 :
392 : static char *
393 0 : _get_alg(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
394 : {
395 0 : int alg_nid = NID_undef;
396 :
397 0 : switch (el) {
398 0 : case XMPP_CERT_KEYALG: {
399 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
400 : alg_nid = OBJ_obj2nid(err_cert->cert_info->key->algor->algorithm);
401 : #else
402 0 : X509_PUBKEY *pubkey = X509_get_X509_PUBKEY(err_cert);
403 0 : ASN1_OBJECT *ppkalg = NULL;
404 0 : if (X509_PUBKEY_get0_param(&ppkalg, NULL, NULL, NULL, pubkey)) {
405 0 : alg_nid = OBJ_obj2nid(ppkalg);
406 : }
407 : #endif
408 0 : } break;
409 0 : case XMPP_CERT_SIGALG: {
410 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
411 : alg_nid = OBJ_obj2nid(err_cert->sig_alg->algorithm);
412 : #else
413 0 : const X509_ALGOR *palg;
414 0 : X509_get0_signature(NULL, &palg, err_cert);
415 0 : alg_nid = OBJ_obj2nid(palg->algorithm);
416 : #endif
417 0 : } break;
418 : default:
419 : break;
420 : }
421 0 : if (alg_nid != NID_undef) {
422 0 : const char *alg = OBJ_nid2ln(alg_nid);
423 0 : if (alg) {
424 0 : return strophe_strdup(ctx, alg);
425 : }
426 : }
427 : return NULL;
428 : }
429 :
430 0 : static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, X509 *cert)
431 : {
432 0 : char *subject, *issuer, buf[32];
433 0 : xmpp_tlscert_t *tlscert = tlscert_new(ctx);
434 0 : if (!tlscert)
435 0 : return NULL;
436 :
437 0 : BIO *b = BIO_new(BIO_s_mem());
438 0 : if (!b)
439 0 : goto error_out;
440 0 : PEM_write_bio_X509(b, cert);
441 0 : BUF_MEM *bptr;
442 0 : BIO_get_mem_ptr(b, &bptr);
443 0 : tlscert->pem = strophe_alloc(ctx, bptr->length + 1);
444 0 : if (!tlscert->pem)
445 0 : goto error_out;
446 0 : memcpy(tlscert->pem, bptr->data, bptr->length);
447 0 : tlscert->pem[bptr->length] = '\0';
448 0 : BIO_free(b);
449 :
450 0 : subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
451 0 : if (!subject)
452 0 : goto error_out;
453 0 : tlscert->elements[XMPP_CERT_SUBJECT] = strophe_strdup(ctx, subject);
454 0 : OPENSSL_free(subject);
455 0 : issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
456 0 : if (!issuer)
457 0 : goto error_out;
458 0 : tlscert->elements[XMPP_CERT_ISSUER] = strophe_strdup(ctx, issuer);
459 0 : OPENSSL_free(issuer);
460 :
461 0 : tlscert->elements[XMPP_CERT_NOTBEFORE] =
462 0 : _asn1_time_to_str(ctx, X509_get_notBefore(cert));
463 0 : tlscert->elements[XMPP_CERT_NOTAFTER] =
464 0 : _asn1_time_to_str(ctx, X509_get_notAfter(cert));
465 :
466 0 : tlscert->elements[XMPP_CERT_FINGERPRINT_SHA1] =
467 0 : _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA1);
468 0 : tlscert->elements[XMPP_CERT_FINGERPRINT_SHA256] =
469 0 : _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA256);
470 :
471 0 : strophe_snprintf(buf, sizeof(buf), "%ld", X509_get_version(cert) + 1);
472 0 : tlscert->elements[XMPP_CERT_VERSION] = strophe_strdup(ctx, buf);
473 :
474 0 : tlscert->elements[XMPP_CERT_KEYALG] = _get_alg(ctx, cert, XMPP_CERT_KEYALG);
475 0 : tlscert->elements[XMPP_CERT_SIGALG] = _get_alg(ctx, cert, XMPP_CERT_SIGALG);
476 :
477 0 : ASN1_INTEGER *serial = X509_get_serialNumber(cert);
478 0 : BIGNUM *bn = ASN1_INTEGER_to_BN(serial, NULL);
479 0 : if (bn) {
480 0 : char *serialnumber = BN_bn2hex(bn);
481 0 : if (serialnumber) {
482 0 : tlscert->elements[XMPP_CERT_SERIALNUMBER] =
483 0 : strophe_strdup(ctx, serialnumber);
484 0 : OPENSSL_free(serialnumber);
485 : }
486 0 : BN_free(bn);
487 : }
488 :
489 0 : GENERAL_NAMES *names = _tls_cert_get_names(cert);
490 0 : if (names) {
491 0 : int j, num_names = sk_GENERAL_NAME_num(names);
492 : size_t n = 0;
493 0 : for (j = 0; j < num_names; ++j) {
494 0 : char *res;
495 0 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
496 0 : if (_tls_dnsname_to_string(name, &res))
497 0 : continue;
498 0 : if (tlscert_add_dnsname(tlscert, res))
499 0 : strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n,
500 : res);
501 0 : n++;
502 0 : OPENSSL_free(res);
503 : }
504 0 : GENERAL_NAMES_free(names);
505 : }
506 :
507 : return tlscert;
508 0 : error_out:
509 0 : xmpp_tlscert_free(tlscert);
510 : return NULL;
511 : }
512 :
513 0 : static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
514 : {
515 0 : if (preverify_ok == 1)
516 : return 1;
517 :
518 0 : SSL *ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
519 : SSL_get_ex_data_X509_STORE_CTX_idx());
520 0 : xmpp_conn_t *conn = SSL_get_app_data(ssl);
521 :
522 0 : if (!conn->certfail_handler) {
523 0 : strophe_error(conn->ctx, "tls",
524 : "No certfail handler set, canceling connection attempt");
525 0 : return 0;
526 : }
527 :
528 0 : X509 *err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
529 :
530 0 : xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, err_cert);
531 :
532 0 : if (!tlscert)
533 : return 0;
534 :
535 0 : strophe_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
536 : preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
537 : tlscert->elements[XMPP_CERT_ISSUER]);
538 :
539 0 : int ret = conn->certfail_handler(
540 : tlscert,
541 0 : X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx)));
542 :
543 0 : xmpp_tlscert_free(tlscert);
544 :
545 0 : return ret;
546 : }
547 :
548 8 : static int _tls_password_callback(char *buf, int size, int rwflag, void *u)
549 : {
550 8 : UNUSED(rwflag);
551 8 : return tls_caching_password_callback(buf, size, u);
552 : }
553 :
554 0 : tls_t *tls_new(xmpp_conn_t *conn)
555 : {
556 0 : tls_t *tls = strophe_alloc(conn->ctx, sizeof(*tls));
557 :
558 0 : if (tls) {
559 0 : int ret;
560 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
561 : /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
562 0 : X509_VERIFY_PARAM *param;
563 : #endif
564 0 : memset(tls, 0, sizeof(*tls));
565 :
566 0 : tls->ctx = conn->ctx;
567 0 : tls->sock = conn->sock;
568 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
569 : tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
570 : #else
571 0 : tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
572 : #endif
573 0 : if (tls->ssl_ctx == NULL)
574 0 : goto err;
575 :
576 : /* Enable bug workarounds. */
577 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
578 :
579 : /* Disable insecure SSL/TLS versions. */
580 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv2); /* DROWN */
581 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv3); /* POODLE */
582 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_TLSv1); /* BEAST */
583 :
584 0 : if (conn->password_callback) {
585 0 : SSL_CTX_set_default_passwd_cb(tls->ssl_ctx, _tls_password_callback);
586 0 : SSL_CTX_set_default_passwd_cb_userdata(tls->ssl_ctx, conn);
587 : }
588 :
589 0 : if (conn->tls_client_cert && conn->tls_client_key) {
590 0 : unsigned int retries = 0;
591 0 : tls->client_cert = _tls_cert_read(conn);
592 0 : if (!tls->client_cert) {
593 0 : strophe_error(tls->ctx, "tls",
594 : "could not read client certificate");
595 0 : goto err_free_ctx;
596 : }
597 :
598 0 : SSL_CTX_use_certificate_file(tls->ssl_ctx, conn->tls_client_cert,
599 : SSL_FILETYPE_PEM);
600 0 : while (retries++ < conn->password_retries) {
601 0 : if (SSL_CTX_use_PrivateKey_file(
602 0 : tls->ssl_ctx, conn->tls_client_key, SSL_FILETYPE_PEM)) {
603 : break;
604 : }
605 0 : tls_clear_password_cache(conn);
606 0 : unsigned long err = ERR_peek_error();
607 0 : if ((ERR_GET_LIB(err) == ERR_LIB_EVP &&
608 0 : ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) ||
609 0 : (ERR_GET_LIB(err) == ERR_LIB_PEM &&
610 0 : ERR_GET_REASON(err) == PEM_R_BAD_DECRYPT)) {
611 0 : strophe_debug(tls->ctx, "tls", "wrong password?");
612 0 : continue;
613 : }
614 0 : strophe_error(tls->ctx, "tls",
615 : "could not use private key %d %d",
616 : ERR_GET_LIB(err), ERR_GET_REASON(err));
617 0 : goto err_free_ctx;
618 : }
619 0 : } else if (conn->tls_client_cert) {
620 0 : EVP_PKEY *pkey = NULL;
621 0 : STACK_OF(X509) *ca = NULL;
622 0 : X509 *cert = _tls_cert_read_p12(conn, &pkey, &ca);
623 0 : if (!cert) {
624 0 : goto err_free_ctx;
625 : }
626 :
627 0 : SSL_CTX_use_cert_and_key(tls->ssl_ctx, cert, pkey, ca, 1);
628 :
629 0 : if (pkey)
630 0 : EVP_PKEY_free(pkey);
631 0 : if (ca)
632 0 : sk_X509_pop_free(ca, X509_free);
633 0 : tls->client_cert = cert;
634 : } else {
635 : /* If the server asks for a client certificate, don't send one. */
636 0 : SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
637 : }
638 :
639 0 : SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
640 :
641 0 : ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
642 0 : if (ret == 0 && !conn->tls_trust) {
643 : /*
644 : * Returns 1 on success and 0 on failure. A missing default
645 : * location is still treated as a success.
646 : * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
647 : */
648 0 : strophe_error(tls->ctx, "tls",
649 : "SSL_CTX_set_default_verify_paths() failed");
650 0 : goto err_free_cert;
651 : }
652 :
653 0 : if (conn->tls_cafile || conn->tls_capath) {
654 0 : if (SSL_CTX_load_verify_locations(tls->ssl_ctx, conn->tls_cafile,
655 0 : conn->tls_capath) == 0) {
656 0 : strophe_error(tls->ctx, "tls",
657 : "SSL_CTX_load_verify_locations() failed");
658 0 : goto err_free_cert;
659 : }
660 : }
661 :
662 0 : tls->ssl = SSL_new(tls->ssl_ctx);
663 0 : if (tls->ssl == NULL)
664 0 : goto err_free_cert;
665 :
666 : #if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
667 : /* Enable SNI. */
668 0 : SSL_set_tlsext_host_name(tls->ssl, conn->domain);
669 : #endif
670 :
671 : /* Trust server's certificate when user sets the flag explicitly.
672 : * Otherwise call the verification callback */
673 0 : if (conn->tls_trust)
674 0 : SSL_set_verify(tls->ssl, SSL_VERIFY_NONE, NULL);
675 : else
676 0 : SSL_set_verify(tls->ssl, SSL_VERIFY_PEER, _tls_verify);
677 0 : SSL_set_app_data(tls->ssl, conn);
678 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
679 : /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
680 0 : param = SSL_get0_param(tls->ssl);
681 :
682 : /*
683 : * Allow only complete wildcards. RFC 6125 discourages wildcard usage
684 : * completely, and lists internationalized domain names as a reason
685 : * against partial wildcards.
686 : * See https://tools.ietf.org/html/rfc6125#section-7.2 for more
687 : * information.
688 : */
689 0 : X509_VERIFY_PARAM_set_hostflags(param,
690 : X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
691 0 : X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
692 : #endif
693 :
694 0 : ret = SSL_set_fd(tls->ssl, conn->sock);
695 0 : if (ret <= 0)
696 0 : goto err_free_ssl;
697 : }
698 :
699 : return tls;
700 :
701 0 : err_free_ssl:
702 0 : SSL_free(tls->ssl);
703 0 : err_free_cert:
704 0 : X509_free(tls->client_cert);
705 0 : err_free_ctx:
706 0 : SSL_CTX_free(tls->ssl_ctx);
707 0 : err:
708 0 : strophe_free(conn->ctx, tls);
709 0 : _tls_log_error(conn->ctx);
710 0 : return NULL;
711 : }
712 :
713 0 : void tls_free(tls_t *tls)
714 : {
715 0 : SSL_free(tls->ssl);
716 0 : X509_free(tls->client_cert);
717 0 : SSL_CTX_free(tls->ssl_ctx);
718 0 : strophe_free(tls->ctx, tls);
719 0 : }
720 :
721 0 : xmpp_tlscert_t *tls_peer_cert(xmpp_conn_t *conn)
722 : {
723 0 : if (conn && conn->tls && conn->tls->ssl) {
724 0 : X509 *cert = SSL_get_peer_certificate(conn->tls->ssl);
725 0 : if (cert) {
726 0 : xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, cert);
727 0 : X509_free(cert);
728 0 : return tlscert;
729 : }
730 : }
731 : return NULL;
732 : }
733 :
734 0 : int tls_set_credentials(tls_t *tls, const char *cafilename)
735 : {
736 0 : UNUSED(tls);
737 0 : UNUSED(cafilename);
738 0 : return -1;
739 : }
740 :
741 0 : int tls_start(tls_t *tls)
742 : {
743 0 : int error;
744 0 : int ret;
745 0 : long x509_res;
746 :
747 : /* Since we're non-blocking, loop the connect call until it
748 : succeeds or fails */
749 0 : while (1) {
750 0 : ret = SSL_connect(tls->ssl);
751 0 : error = ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0;
752 :
753 0 : if (ret == -1 && tls_is_recoverable(error)) {
754 : /* wait for something to happen on the sock before looping back */
755 0 : _tls_sock_wait(tls, error);
756 0 : continue;
757 : }
758 :
759 : /* success or fatal error */
760 0 : break;
761 : }
762 :
763 0 : x509_res = SSL_get_verify_result(tls->ssl);
764 0 : if (x509_res == X509_V_OK) {
765 0 : strophe_debug(tls->ctx, "tls", "Certificate verification passed");
766 : } else {
767 0 : strophe_debug(tls->ctx, "tls",
768 : "Certificate verification FAILED, result=%s(%ld)",
769 : TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
770 0 : if (ret > 0)
771 0 : strophe_debug(tls->ctx, "tls", "User decided to connect anyways");
772 : }
773 0 : _tls_dump_cert_info(tls);
774 :
775 0 : _tls_set_error(tls, error);
776 0 : return ret <= 0 ? 0 : 1;
777 : }
778 :
779 0 : int tls_stop(tls_t *tls)
780 : {
781 0 : int retries = 0;
782 0 : int error;
783 0 : int ret;
784 :
785 : /* According to OpenSSL.org, we must not call SSL_shutdown(3)
786 : if a previous fatal error has occurred on a connection. */
787 0 : if (tls->lasterror == SSL_ERROR_SYSCALL || tls->lasterror == SSL_ERROR_SSL)
788 : return 1;
789 :
790 0 : while (1) {
791 0 : ++retries;
792 0 : ret = SSL_shutdown(tls->ssl);
793 0 : error = ret < 0 ? SSL_get_error(tls->ssl, ret) : 0;
794 0 : if (ret == 1 || !tls_is_recoverable(error) ||
795 : retries >= TLS_SHUTDOWN_MAX_RETRIES) {
796 : break;
797 : }
798 0 : _tls_sock_wait(tls, error);
799 : }
800 0 : if (error == SSL_ERROR_SYSCALL && errno == 0) {
801 : /*
802 : * Handle special case when peer closes connection instead of
803 : * proper shutdown.
804 : */
805 0 : error = 0;
806 0 : ret = 1;
807 : }
808 0 : _tls_set_error(tls, error);
809 :
810 0 : return ret <= 0 ? 0 : 1;
811 : }
812 :
813 0 : int tls_is_recoverable(int error)
814 : {
815 0 : return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
816 0 : error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
817 : error == SSL_ERROR_WANT_ACCEPT);
818 : }
819 :
820 0 : int tls_pending(tls_t *tls)
821 : {
822 0 : return SSL_pending(tls->ssl);
823 : }
824 :
825 0 : int tls_read(tls_t *tls, void *buff, size_t len)
826 : {
827 0 : int ret;
828 :
829 0 : ret = SSL_read(tls->ssl, buff, len);
830 0 : _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
831 :
832 0 : return ret;
833 : }
834 :
835 0 : int tls_write(tls_t *tls, const void *buff, size_t len)
836 : {
837 0 : int ret;
838 :
839 0 : ret = SSL_write(tls->ssl, buff, len);
840 0 : _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
841 :
842 0 : return ret;
843 : }
844 :
845 0 : int tls_clear_pending_write(tls_t *tls)
846 : {
847 0 : UNUSED(tls);
848 0 : return 0;
849 : }
850 :
851 0 : static void _tls_sock_wait(tls_t *tls, int error)
852 : {
853 0 : struct timeval tv;
854 0 : fd_set rfds;
855 0 : fd_set wfds;
856 0 : int nfds;
857 0 : int ret;
858 :
859 0 : if (error == SSL_ERROR_NONE)
860 0 : return;
861 :
862 0 : FD_ZERO(&rfds);
863 0 : FD_ZERO(&wfds);
864 0 : if (error == SSL_ERROR_WANT_READ)
865 0 : FD_SET(tls->sock, &rfds);
866 0 : if (error == SSL_ERROR_WANT_WRITE)
867 0 : FD_SET(tls->sock, &wfds);
868 0 : nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
869 0 : ? tls->sock + 1
870 0 : : 0;
871 0 : do {
872 0 : tv.tv_sec = TLS_TIMEOUT_SEC;
873 0 : tv.tv_usec = TLS_TIMEOUT_USEC;
874 0 : ret = select(nfds, &rfds, &wfds, NULL, &tv);
875 0 : } while (ret == -1 && errno == EINTR);
876 : }
877 :
878 0 : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
879 : {
880 0 : return (error >= 0 && (size_t)error < tbl_size) ? tbl[error] : "UNKNOWN";
881 : }
882 :
883 0 : static void _tls_set_error(tls_t *tls, int error)
884 : {
885 0 : if (error != 0 && !tls_is_recoverable(error)) {
886 0 : strophe_debug(tls->ctx, "tls", "error=%s(%d) errno=%d lasterror=%d",
887 0 : TLS_ERROR_STR(error, tls_errors), error, errno,
888 : tls->lasterror);
889 0 : _tls_log_error(tls->ctx);
890 0 : } else if (tls->lasterror && tls->lasterror != error) {
891 0 : strophe_debug_verbose(1, tls->ctx, "tls", "overwrite lasterror=%d",
892 : tls->lasterror);
893 : }
894 0 : tls->lasterror = error;
895 0 : }
896 :
897 0 : static void _tls_log_error(xmpp_ctx_t *ctx)
898 : {
899 0 : unsigned long e;
900 :
901 0 : do {
902 0 : e = ERR_get_error();
903 0 : if (e != 0) {
904 0 : strophe_debug(
905 : ctx, "tls", "error:%08X:%s:%s:%s", e, ERR_lib_error_string(e),
906 : STROPHE_ERR_func_error_string(e), ERR_reason_error_string(e));
907 : }
908 0 : } while (e != 0);
909 0 : }
910 :
911 0 : static void _tls_dump_cert_info(tls_t *tls)
912 : {
913 0 : X509 *cert;
914 0 : char *name;
915 :
916 0 : cert = SSL_get_peer_certificate(tls->ssl);
917 0 : if (cert == NULL)
918 0 : strophe_debug(tls->ctx, "tls", "Certificate was not presented by peer");
919 : else {
920 0 : name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
921 0 : if (name != NULL) {
922 0 : strophe_debug(tls->ctx, "tls", "Subject=%s", name);
923 0 : OPENSSL_free(name);
924 : }
925 0 : name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
926 0 : if (name != NULL) {
927 0 : strophe_debug(tls->ctx, "tls", "Issuer=%s", name);
928 0 : OPENSSL_free(name);
929 : }
930 0 : X509_free(cert);
931 : }
932 0 : }
933 :
934 8 : static X509 *_tls_cert_read_x509(xmpp_conn_t *conn)
935 : {
936 8 : if (conn->tls && conn->tls->client_cert)
937 : return conn->tls->client_cert;
938 8 : BIO *f = BIO_new_file(conn->tls_client_cert, "r");
939 8 : if (!f) {
940 0 : strophe_debug(conn->ctx, "tls", "f == NULL");
941 0 : return NULL;
942 : }
943 8 : X509 *c = PEM_read_bio_X509(f, NULL, NULL, NULL);
944 8 : BIO_free(f);
945 8 : if (!c) {
946 0 : _tls_log_error(conn->ctx);
947 : }
948 : return c;
949 : }
950 :
951 32 : static int _tls_parse_p12(PKCS12 *p12,
952 : const char *pass,
953 : EVP_PKEY **pkey,
954 : X509 **cert,
955 : STACK_OF(X509) * *ca)
956 : {
957 : /* For some reason `PKCS12_parse()` fails without a `EVP_PKEY`
958 : * so if the user doesn't want it, use a local one and free it
959 : * again directly after parsing.
960 : */
961 32 : EVP_PKEY *pkey_;
962 32 : if (!pkey)
963 32 : pkey = &pkey_;
964 32 : int parse_ok = PKCS12_parse(p12, pass, pkey, cert, ca);
965 32 : if (pkey == &pkey_ && pkey_)
966 24 : EVP_PKEY_free(pkey_);
967 32 : return parse_ok;
968 : }
969 :
970 : static X509 *
971 24 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca)
972 : {
973 24 : if (conn->tls && conn->tls->client_cert && !pkey && !ca)
974 24 : return conn->tls->client_cert;
975 24 : X509 *cert = NULL;
976 24 : PKCS12 *p12 = NULL;
977 24 : BIO *f = BIO_new_file(conn->tls_client_cert, "rb");
978 24 : if (!f) {
979 0 : strophe_debug(conn->ctx, "tls", "f == NULL");
980 0 : goto error_out;
981 : }
982 24 : p12 = d2i_PKCS12_bio(f, NULL);
983 24 : BIO_free(f);
984 24 : if (!p12) {
985 0 : strophe_debug(conn->ctx, "tls", "Could not read p12 file");
986 0 : goto error_out;
987 : }
988 :
989 : /* First try to open file w/o a pass */
990 24 : if (_tls_parse_p12(p12, NULL, pkey, &cert, ca)) {
991 16 : goto success;
992 : }
993 8 : cert = NULL;
994 :
995 8 : unsigned int retries = 0;
996 :
997 8 : pem_password_cb *cb = PEM_def_callback;
998 8 : void *userdata = NULL;
999 8 : if (conn->password_callback) {
1000 8 : cb = _tls_password_callback;
1001 8 : userdata = conn;
1002 : }
1003 :
1004 8 : while (retries++ < conn->password_retries) {
1005 8 : char pass[PEM_BUFSIZE + 1];
1006 8 : int passlen = cb(pass, PEM_BUFSIZE, 0, userdata);
1007 8 : if (passlen < 0 || passlen > PEM_BUFSIZE)
1008 0 : goto error_out;
1009 8 : int parse_ok = _tls_parse_p12(p12, pass, pkey, &cert, ca);
1010 8 : if (parse_ok) {
1011 8 : goto success;
1012 : }
1013 0 : cert = NULL;
1014 0 : tls_clear_password_cache(conn);
1015 0 : int err = ERR_peek_last_error();
1016 0 : if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
1017 0 : ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
1018 0 : strophe_debug(conn->ctx, "tls",
1019 : "Entered password is most likely wrong!");
1020 0 : continue;
1021 : }
1022 0 : strophe_debug(conn->ctx, "tls", "Could not parse PKCS#12");
1023 0 : goto error_out;
1024 : }
1025 0 : error_out:
1026 0 : _tls_log_error(conn->ctx);
1027 24 : success:
1028 24 : if (p12)
1029 24 : PKCS12_free(p12);
1030 24 : return cert;
1031 : }
1032 :
1033 32 : static X509 *_tls_cert_read(xmpp_conn_t *conn)
1034 : {
1035 32 : if (conn->tls && conn->tls->client_cert)
1036 : return conn->tls->client_cert;
1037 32 : if (conn->tls_client_cert && !conn->tls_client_key) {
1038 24 : return _tls_cert_read_p12(conn, NULL, NULL);
1039 : }
1040 8 : return _tls_cert_read_x509(conn);
1041 : }
1042 :
1043 58 : static int _tls_xaddr_nid(void)
1044 : {
1045 58 : static int xaddr_nid = NID_undef;
1046 58 : if (xaddr_nid == NID_undef) {
1047 2 : xaddr_nid = OBJ_sn2nid("id-on-xmppAddr");
1048 : }
1049 58 : if (xaddr_nid == NID_undef) {
1050 0 : xaddr_nid = OBJ_create("1.3.6.1.5.5.7.8.5", "id-on-xmppAddr",
1051 : "XmppAddr Identifier");
1052 : }
1053 58 : return xaddr_nid;
1054 : }
1055 :
1056 32 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn)
1057 : {
1058 32 : X509 *client_cert;
1059 32 : GENERAL_NAMES *names = NULL;
1060 32 : client_cert = _tls_cert_read(conn);
1061 32 : if (!client_cert)
1062 : return NULL;
1063 32 : names = _tls_cert_get_names(client_cert);
1064 32 : if (!conn->tls || !conn->tls->client_cert)
1065 32 : X509_free(client_cert);
1066 : return names;
1067 : }
1068 :
1069 32 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert)
1070 : {
1071 32 : int san = X509_get_ext_by_NID(client_cert, NID_subject_alt_name, 0);
1072 32 : X509_EXTENSION *san_ext = X509_get_ext(client_cert, san);
1073 32 : if (!san_ext)
1074 32 : return NULL;
1075 32 : ASN1_OCTET_STRING *data = X509_EXTENSION_get_data(san_ext);
1076 32 : if (!data)
1077 : return NULL;
1078 32 : const unsigned char *d = ASN1_STRING_get0_data(data);
1079 32 : if (!d)
1080 : return NULL;
1081 32 : return d2i_GENERAL_NAMES(NULL, &d, ASN1_STRING_length(data));
1082 : }
1083 :
1084 : /** Convert GENERAL_NAME* to a string
1085 : *
1086 : * This checks whether the GENERAL_NAME* that is given has the
1087 : * correct id-on-xmppAddr set and then optionally converts this
1088 : * form ASN.1 to a string/char*.
1089 : *
1090 : * When `res` pointer is set to NULL this method doesn't allocate
1091 : * the result but only checks whether it is in the correct format.
1092 : *
1093 : * @param name Pointer to the GENERAL_NAME that shall be converted
1094 : * @param res Result-pointer (optional, can be NULL)
1095 : *
1096 : * @return classic Unix style - 0=success, 1=error
1097 : */
1098 104 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res)
1099 : {
1100 104 : ASN1_OBJECT *oid;
1101 104 : ASN1_TYPE *val;
1102 104 : if (!name || name->type != GEN_OTHERNAME)
1103 104 : return 1;
1104 56 : if (GENERAL_NAME_get0_otherName(name, &oid, &val) == 0)
1105 : return 1;
1106 56 : if (OBJ_obj2nid(oid) != _tls_xaddr_nid() || !val)
1107 : return 1;
1108 56 : if (!res)
1109 : return 0;
1110 40 : if (ASN1_STRING_to_UTF8((unsigned char **)res, val->value.asn1_string) < 0)
1111 : return 1;
1112 : return 0;
1113 : }
1114 :
1115 0 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res)
1116 : {
1117 0 : ASN1_STRING *str;
1118 0 : if (!name || name->type != GEN_DNS)
1119 : return 1;
1120 0 : str = GENERAL_NAME_get0_value(name, NULL);
1121 0 : if (str == NULL)
1122 : return 1;
1123 0 : if (!res)
1124 : return 0;
1125 0 : if (ASN1_STRING_to_UTF8((unsigned char **)res, str) < 0)
1126 : return 1;
1127 : return 0;
1128 : }
|
