1 /* Copyright (C) 2009-2011, Martin Johansson <martin@fatbob.nu>
2 Copyright (C) 2005-2011, Thorvald Natvig <thorvald@natvig.com>
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions
10 - Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12 - Redistributions in binary form must reproduce the above copyright notice,
13 this list of conditions and the following disclaimer in the documentation
14 and/or other materials provided with the distribution.
15 - Neither the name of the Developers nor the names of its contributors may
16 be used to endorse or promote products derived from this software without
17 specific prior written permission.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 #include <polarssl/havege.h>
44 #include <polarssl/certs.h>
45 #include <polarssl/x509.h>
46 #include <polarssl/ssl.h>
47 #include <polarssl/net.h>
49 #define CA_CRT_FILENAME "ca.crt"
53 SSL_EDH_RSA_AES_256_SHA,
54 SSL_EDH_RSA_CAMELLIA_256_SHA,
55 SSL_EDH_RSA_DES_168_SHA,
57 SSL_RSA_CAMELLIA_256_SHA,
59 SSL_RSA_CAMELLIA_128_SHA,
65 static x509_cert certificate;
66 static rsa_context key;
67 bool_t builtInTestCertificate;
69 havege_state hs; /* exported to crypt.c */
72 const char *my_dhm_P =
73 "9CE85640903BF123906947FEDE767261" \
74 "D9B4A973EB8F7D984A8C656E2BCC161C" \
75 "183D4CA471BA78225F940F16D1D99CA3" \
76 "E66152CC68EDCE1311A390F307741835" \
77 "44FF6AB553EC7073AD0CB608F2A3B480" \
78 "19E6C02BCED40BD30E91BB2469089670" \
79 "DEF409C08E8AC24D1732A6128D2220DC53";
80 const char *my_dhm_G = "4";
82 const char *test_key =
83 "-----BEGIN RSA PRIVATE KEY-----\r\n"
84 "MIICXAIBAAKBgQC/zZ5p/st9JUgoFIuNCwyYJhKhnqKlAk36RJJAXhJ/3FZCThQK\r\n"
85 "J0jxMCjnQb9envZPIKrAfyDtlEGKU8OI2HvDsFL7Y2fNjew0R9DoUyzPRVBInfW9\r\n"
86 "JP03aiOldpooTjXBrzoZV+DGqRYJE/IRJEyXir5NEJu624bMJm0XDVkxiwIDAQAB\r\n"
87 "AoGAPcFJiR01jYSsd+Mtj2sIUhCoHQuDmJdmXfcoE7t2P17FEzIqd55weN+lu9fK\r\n"
88 "cv/BlHaTI8mK45PBinUv1ubE6gzzyLtNgBW7ko8i23YQNMS4+8ApZZoCFsVbN533\r\n"
89 "/mFYcOmWpdgIsAOyi3gAyO5OyGA71a3gkNX+MDYc7PgbTkkCQQDq1NN/j6xVw4qc\r\n"
90 "3qunsMOVJxln7Gkgt0fOrCV0WltJNkKYiARwtpvB/SHIj6nHhun+J/ee/v+QjAL4\r\n"
91 "aUwC8OmnAkEA0RfWWVQ2Yxk9QjRcqcpDddtc+9xxM6Dt+edGDSYKRUB/S2cl/Sdg\r\n"
92 "abFdrFEnFdO03VknCrqUgweegeUJhU1tfQJBAKLFFjxK59cijMejCDRZr5eI3HFO\r\n"
93 "Sqgkoh8871Ew+ClM9OgpD3rY+CmEPZB5E+N7PmGublLEyXv1sHFi+w7m0e0CQDnH\r\n"
94 "eoYIzVapHNJ0ob6Rk/63dYRrsCRyLhDGpgbwIhps7kAp6sd/4BaU2qvJaSGQ9QPN\r\n"
95 "pQpD8NIcguKmJfFeKgkCQBABatS74xI2UAW/IIbRBg8a8z4v5JxEnQwp0EtmON2I\r\n"
96 "+AVBenUVFjpdjaaQ2/2IEgEwnzRfbERQfUlAkjczRaM=\r\n"
97 "-----END RSA PRIVATE KEY-----\r\n";
99 const char *test_cert =
100 "-----BEGIN CERTIFICATE-----\r\n"
101 "MIICfDCCAeWgAwIBAgIJANEN9Jb9sp0oMA0GCSqGSIb3DQEBBQUAMFcxCzAJBgNV\r\n"
102 "BAYTAlNFMRMwEQYDVQQHDApHb3RoZW5idXJnMRAwDgYDVQQKDAd1TXVybXVyMSEw\r\n"
103 "HwYDVQQDDBh1TXVybXVyIHRlc3QgY2VydGlmaWNhdGUwHhcNMTEwMzIyMjIxMTEy\r\n"
104 "WhcNMjEwMzE5MjIxMTEyWjBXMQswCQYDVQQGEwJTRTETMBEGA1UEBwwKR290aGVu\r\n"
105 "YnVyZzEQMA4GA1UECgwHdU11cm11cjEhMB8GA1UEAwwYdU11cm11ciB0ZXN0IGNl\r\n"
106 "cnRpZmljYXRlMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC/zZ5p/st9JUgo\r\n"
107 "FIuNCwyYJhKhnqKlAk36RJJAXhJ/3FZCThQKJ0jxMCjnQb9envZPIKrAfyDtlEGK\r\n"
108 "U8OI2HvDsFL7Y2fNjew0R9DoUyzPRVBInfW9JP03aiOldpooTjXBrzoZV+DGqRYJ\r\n"
109 "E/IRJEyXir5NEJu624bMJm0XDVkxiwIDAQABo1AwTjAdBgNVHQ4EFgQUyI0/J6gS\r\n"
110 "G7vEZl1nKq9rAYAg/TMwHwYDVR0jBBgwFoAUyI0/J6gSG7vEZl1nKq9rAYAg/TMw\r\n"
111 "DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOBgQCGL3T4a7g+MUtcjIq2XLON\r\n"
112 "cN/oPgPpMNcSPj7zQF1NVzjeQagvKIe3mL5sNIYuoIQm1Xm7aH2ueruhH0wkSOf0\r\n"
113 "+7U/g7r70U1CFWzfgwzz3EWRq3hUQmZ9/Xy9V2P/iRrFNyAKE8MneuVv3aAIN6/W\r\n"
114 "rWVxhCquqhFM3yIGe0f6hw==\r\n"
115 "-----END CERTIFICATE-----\r\n";
118 static void initTestCert()
121 builtInTestCertificate = true;
122 rc = x509parse_crt(&certificate, (unsigned char *)test_cert,
125 Log_fatal("Could not parse built-in test certificate");
126 rc = x509parse_crt(&certificate, (unsigned char *)test_cert,
129 Log_fatal("Could not parse built-in test certificate");
132 static void initTestKey()
136 rc = x509parse_key(&key, (unsigned char *)test_key,
137 strlen(test_key), NULL, 0);
139 Log_fatal("Could not parse built-in test RSA key");
143 * openssl genrsa 1024 > host.key
144 * openssl req -new -x509 -nodes -sha1 -days 365 -key host.key > host.cert
146 static void initCert()
149 char *crtfile = (char *)getStrConf(CERTIFICATE);
152 if (crtfile == NULL) {
153 Log_warn("No certificate file specified");
157 rc = x509parse_crtfile(&certificate, crtfile);
159 Log_warn("Could not read certificate file %s", crtfile);
164 /* Look for CA certificate file in same dir */
165 ca_file = malloc(strlen(crtfile) + strlen(CA_CRT_FILENAME) + 1);
166 strcpy(ca_file, crtfile);
167 p = strrchr(ca_file, '/');
169 strcpy(p + 1, CA_CRT_FILENAME);
171 strcpy(ca_file, CA_CRT_FILENAME);
173 rc = x509parse_crtfile(&certificate, ca_file);
174 if (rc != 0) { /* No CA certifiacte found. Assume self-signed. */
175 Log_info("CA certificate file %s not found. Assuming self-signed certificate.", ca_file);
179 * PolarSSL 0.11 - 0.12,1 has a bug; it ignores the last certificate in the chain.
180 * Read the certificate again so that it gets last in chain. Later releases like 0.14.0 works
181 * fine with the extra certificate, so I don't see any harm in doing so.
183 rc = x509parse_crtfile(&certificate, crtfile);
185 Log_fatal("Could not read certificate file %s", crtfile);
190 static void initKey()
193 char *keyfile = (char *)getStrConf(KEY);
196 Log_fatal("No key file specified");
197 rc = x509parse_keyfile(&key, keyfile, NULL);
199 Log_fatal("Could not read RSA key file %s", keyfile);
202 #define DEBUG_LEVEL 0
203 static void pssl_debug(void *ctx, int level, const char *str)
205 if (level <= DEBUG_LEVEL)
206 Log_debug("PolarSSL [level %d]: %s", level, str);
212 if (builtInTestCertificate) {
213 Log_warn("*** Using built-in test certificate and RSA key ***");
214 Log_warn("*** This is not secure! Please use a CA-signed certificate or create a self-signed certificate ***");
220 Log_info("PolarSSL library initialized");
223 void SSLi_deinit(void)
225 x509_free(&certificate);
229 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
235 ssl = malloc(sizeof(ssl_context));
236 ssn = malloc(sizeof(ssl_session));
238 Log_fatal("Out of memory");
239 memset(ssl, 0, sizeof(ssl_context));
240 memset(ssn, 0, sizeof(ssl_session));
244 Log_fatal("Failed to initalize: %d", rc);
246 ssl_set_endpoint(ssl, SSL_IS_SERVER);
247 ssl_set_authmode(ssl, SSL_VERIFY_OPTIONAL);
249 ssl_set_rng(ssl, havege_rand, &hs);
250 ssl_set_dbg(ssl, pssl_debug, NULL);
251 ssl_set_bio(ssl, net_recv, fd, net_send, fd);
253 ssl_set_ciphers(ssl, ciphers);
254 ssl_set_session(ssl, 0, 0, ssn);
256 ssl_set_ca_chain(ssl, certificate.next, NULL, NULL);
257 ssl_set_own_cert(ssl, &certificate, &key);
258 ssl_set_dh_param(ssl, my_dhm_P, my_dhm_G);
263 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
267 rc = ssl_handshake(ssl);
269 if (rc == POLARSSL_ERR_NET_TRY_AGAIN) {
272 Log_warn("SSL handshake failed: %d", rc);
280 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
283 rc = ssl_read(ssl, buf, len);
284 if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
285 return SSLI_ERROR_WANT_READ;
289 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
292 rc = ssl_write(ssl, buf, len);
293 if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
294 return SSLI_ERROR_WANT_WRITE;
298 int SSLi_get_error(SSL_handle_t *ssl, int code)
303 bool_t SSLi_data_pending(SSL_handle_t *ssl)
305 return ssl_get_bytes_avail(ssl) > 0;
308 void SSLi_shutdown(SSL_handle_t *ssl)
310 ssl_close_notify(ssl);
313 void SSLi_free(SSL_handle_t *ssl)
315 Log_debug("SSLi_free");
316 free(ssl->session); /* XXX - Hmmm. */
326 #include <openssl/x509v3.h>
327 #include <openssl/ssl.h>
328 #include <openssl/err.h>
329 #include <openssl/safestack.h>
332 static SSL_CTX *context;
333 static EVP_PKEY *pkey;
335 static int SSL_add_ext(X509 * crt, int nid, char *value) {
338 X509V3_set_ctx_nodb(&ctx);
339 X509V3_set_ctx(&ctx, crt, crt, NULL, NULL, 0);
340 ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
344 X509_add_ext(crt, ex, -1);
345 X509_EXTENSION_free(ex);
349 static X509 *SSL_readcert(char *certfile)
354 /* open the private key file */
355 fp = fopen(certfile, "r");
357 Log_warn("Unable to open the X509 file %s for reading.", certfile);
361 /* allocate memory for the cert structure */
364 if (PEM_read_X509(fp, &x509, NULL, NULL) == 0) {
365 /* error reading the x509 information - check the error stack */
366 Log_warn("Error trying to read X509 info.");
375 static RSA *SSL_readprivatekey(char *keyfile)
380 /* open the private key file for reading */
381 fp = fopen(keyfile, "r");
383 Log_warn("Unable to open the private key file %s for reading.", keyfile);
387 /* allocate memory for the RSA structure */
390 /* assign a callback function for the password */
392 /* read a private key from file */
393 if (PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL) <= 0) {
394 /* error reading the key - check the error stack */
395 Log_warn("Error trying to read private key.");
404 static void SSL_writecert(char *certfile, X509 *x509)
409 /* prepare a BIO for outputting error messages */
411 err_output = BIO_new_fp(stderr,BIO_NOCLOSE);
413 /* open the private key file */
414 fp = fopen(certfile, "w");
416 BIO_printf(err_output, "Unable to open the X509 file for writing.\n");
417 BIO_free(err_output);
421 if (PEM_write_X509(fp, x509) == 0) {
422 BIO_printf(err_output, "Error trying to write X509 info.\n");
423 ERR_print_errors(err_output);
428 static void SSL_writekey(char *keyfile, RSA *rsa)
432 /* prepare a BIO for outputing error messages */
433 err_output = BIO_new_fp(stderr, BIO_NOCLOSE);
435 /* open the private key file for reading */
436 fp = fopen(keyfile, "w");
438 BIO_printf(err_output, "Unable to open the private key file %s for writing.\n", keyfile);
439 BIO_free(err_output);
443 if (PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL) == 0) {
444 /* error reading the key - check the error stack */
445 BIO_printf(err_output, "Error trying to write private key\n");
446 ERR_print_errors(err_output);
451 static void SSL_initializeCert() {
452 char *crt, *key, *pass;
454 crt = (char *)getStrConf(CERTIFICATE);
455 key = (char *)getStrConf(KEY);
456 pass = (char *)getStrConf(PASSPHRASE);
458 x509 = SSL_readcert(crt);
459 rsa = SSL_readprivatekey(key);
461 pkey = EVP_PKEY_new();
462 EVP_PKEY_assign_RSA(pkey, rsa);
468 qscCert = QSslCertificate(key);
469 if (! qscCert.isNull()) {
470 logthis("Using certificate from key.");
474 if (! qscCert.isNull()) {
475 QSsl::KeyAlgorithm alg = qscCert.publicKey().algorithm();
476 /* Fetch algorith from cert */
477 if (! key.isEmpty()) {
479 qskKey = QSslKey(key, alg, QSsl::Pem, QSsl::PrivateKey, pass);
480 if (qskKey.isNull()) {
481 logthis("Failed to parse key.");
485 if (! crt.isEmpty() && qskKey.isNull()) {
486 /* get key from certificate */
487 qskKey = QSslKey(crt, alg, QSsl::Pem, QSsl::PrivateKey, pass);
488 if (! qskKey.isNull()) {
489 logthis("Using key from certificate.");
497 logthis("Generating new server certificate.");
501 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
503 bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
506 pkey = EVP_PKEY_new();
507 rsa = RSA_generate_key(1024,RSA_F4,NULL,NULL);
508 EVP_PKEY_assign_RSA(pkey, rsa);
510 X509_set_version(x509, 2);
511 ASN1_INTEGER_set(X509_get_serialNumber(x509),1);
512 X509_gmtime_adj(X509_get_notBefore(x509),0);
513 X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365);
514 X509_set_pubkey(x509, pkey);
516 X509_NAME *name=X509_get_subject_name(x509);
518 X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (const uint8_t *)"Murmur Autogenerated Certificate v2", -1, -1, 0);
519 X509_set_issuer_name(x509, name);
520 SSL_add_ext(x509, NID_basic_constraints, "critical,CA:FALSE");
521 SSL_add_ext(x509, NID_ext_key_usage, "serverAuth,clientAuth");
522 SSL_add_ext(x509, NID_subject_key_identifier, "hash");
523 SSL_add_ext(x509, NID_netscape_comment, "Generated from umurmur");
525 X509_sign(x509, pkey, EVP_md5());
527 SSL_writecert(crt, x509);
528 SSL_writekey(key, rsa);
535 const SSL_METHOD *method;
538 STACK_OF(SSL_CIPHER) *cipherlist = NULL, *cipherlist_new = NULL;
540 char cipherstring[1024];
543 OpenSSL_add_all_algorithms(); /* load & register all cryptos, etc. */
544 SSL_load_error_strings(); /* load all error messages */
545 ERR_load_crypto_strings(); /* load all error messages */
546 method = SSLv23_server_method(); /* create new server-method instance */
547 context = SSL_CTX_new(method); /* create new context from method */
550 ERR_print_errors_fp(stderr);
553 SSL_initializeCert();
554 if (SSL_CTX_use_certificate(context, x509) <= 0)
555 Log_fatal("Failed to initialize cert");
556 if (SSL_CTX_use_PrivateKey(context, pkey) <= 0) {
557 ERR_print_errors_fp(stderr);
558 Log_fatal("Failed to initialize private key");
561 /* Set cipher list */
562 ssl = SSL_new(context);
563 cipherlist = (STACK_OF(SSL_CIPHER) *) SSL_get_ciphers(ssl);
564 cipherlist_new = (STACK_OF(SSL_CIPHER) *) sk_SSL_CIPHER_new_null();
566 for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist, i)) != NULL; i++) {
567 if (SSL_CIPHER_get_bits(cipher, NULL) >= 128) {
568 sk_SSL_CIPHER_push(cipherlist_new, cipher);
571 Log_debug("List of ciphers:");
572 if (cipherlist_new) {
573 for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
574 Log_debug("%s", SSL_CIPHER_get_name(cipher));
575 offset += snprintf(cipherstring + offset, 1024 - offset, "%s:", SSL_CIPHER_get_name(cipher));
577 cipherstring[offset - 1] = '\0';
581 sk_SSL_CIPHER_free(cipherlist_new);
583 if (strlen(cipherstring) == 0)
584 Log_fatal("No suitable ciphers found!");
586 if (SSL_CTX_set_cipher_list(context, cipherstring) == 0)
587 Log_fatal("Failed to set cipher list!");
591 Log_info("OpenSSL library initialized");
595 void SSLi_deinit(void)
597 SSL_CTX_free(context);
601 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
604 rc = SSL_accept(ssl);
606 if (SSL_get_error(ssl, rc) == SSL_ERROR_WANT_READ ||
607 SSL_get_error(ssl, rc) == SSL_ERROR_WANT_WRITE) {
608 Log_debug("SSL not ready");
611 Log_warn("SSL error: %s", ERR_error_string(SSL_get_error(ssl, rc), NULL));
619 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
624 ssl = SSL_new(context);
625 SSL_set_fd(ssl, *fd);
626 if (SSLi_nonblockaccept(ssl, SSLready) < 0) {
633 void SSLi_closeconnection(SSL_handle_t *ssl)
638 void SSLi_shutdown(SSL_handle_t *ssl)
643 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
645 return SSL_read(ssl, buf, len);
648 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
650 return SSL_write(ssl, buf, len);
653 int SSLi_get_error(SSL_handle_t *ssl, int code)
655 return SSL_get_error(ssl, code);
658 bool_t SSLi_data_pending(SSL_handle_t *ssl)
660 return SSL_pending(ssl);
663 void SSLi_free(SSL_handle_t *ssl)