1 /* 2 * Copyright (C) 2015 Red Hat, Inc. 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation; either 7 * version 2.1 of the License, or (at your option) any later version. 8 * 9 * This library is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Lesser General Public License for more details. 13 * 14 * You should have received a copy of the GNU Lesser General Public 15 * License along with this library. If not, see 16 * <http://www.gnu.org/licenses/>. 17 * 18 * Author: Daniel P. Berrange <berrange@redhat.com> 19 */ 20 21 #include "qemu/osdep.h" 22 23 #include "crypto-tls-x509-helpers.h" 24 #include "crypto/init.h" 25 #include "qemu/sockets.h" 26 27 #ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT 28 29 /* 30 * This stores some static data that is needed when 31 * encoding extensions in the x509 certs 32 */ 33 asn1_node pkix_asn1; 34 35 /* 36 * To avoid consuming random entropy to generate keys, 37 * here's one we prepared earlier :-) 38 */ 39 gnutls_x509_privkey_t privkey; 40 # define PRIVATE_KEY \ 41 "-----BEGIN RSA PRIVATE KEY-----\n" \ 42 "MIIG5AIBAAKCAYEAyjWyLSNm5PZvYUKUcDWGqbLX10b2ood+YaFjWSnJrqx/q3qh\n" \ 43 "rVGBJglD25AJENJsmZF3zPP1oMhfIxsXu63Hdkb6Rdlc2RUoUP34x9VC1izH25mR\n" \ 44 "6c8DPDp1d6IraZ/llDMI1HsBFz0qGWtvOHgm815XG4PAr/N8rDsuqfv/cJ01KlnO\n" \ 45 "0OdO5QRXCJf9g/dYd41MPu7wOXk9FqjQlmRoP59HgtJ+zUpE4z+Keruw9cMT9VJj\n" \ 46 "0oT+pQ9ysenqeZ3gbT224T1khrEhT5kifhtFLNyDssRchUUWH0hiqoOO1vgb+850\n" \ 47 "W6/1VdxvuPam48py4diSPi1Vip8NITCOBaX9FIpVp4Ruw4rTPVMNMjq9Cpx/DwMP\n" \ 48 "9MbfXfnaVaZaMrmq67/zPhl0eVbUrecH2hQ3ZB9oIF4GkNskzlWF5+yPy6zqk304\n" \ 49 "AKaiFR6jRyh3YfHo2XFqV8x/hxdsIEXOtEUGhSIcpynsW+ckUCartzu7xbhXjd4b\n" \ 50 "kxJT89+riPFYij09AgMBAAECggGBAKyFkaZXXROeejrmHlV6JZGlp+fhgM38gkRz\n" \ 51 "+Jp7P7rLLAY3E7gXIPQ91WqAAmwazFNdvHPd9USfkCQYmnAi/VoZhrCPmlsQZRxt\n" \ 52 "A5QjjOnEvSPMa6SrXZxGWDCg6R8uMCb4P+FhrPWR1thnRDZOtRTQ+crc50p3mHgt\n" \ 53 "6ktXWIJRbqnag8zSfQqCYGtRmhe8sfsWT+Yl4El4+jjaAVU/B364u7+PLmaiphGp\n" \ 54 "BdJfTsTwEpgtGkPj+osDmhzXcZkfq3V+fz5JLkemsCiQKmn4VJRpg8c3ZmE8NPNt\n" \ 55 "gRtGWZ4W3WKDvhotT65WpQx4+6R8Duux/blNPBmH1Upmwd7kj7GYFBArbCjgd9PT\n" \ 56 "xgfCSUZpgOZHHkcgSB+022a8XncXna7WYYij28SLtwImFyu0nNtqECFQHH5u+k6C\n" \ 57 "LRYBSN+3t3At8dQuk01NVrJBndmjmXRfxpqUtTdeaNgVpdUYRY98s30G68NYGSra\n" \ 58 "aEvhhRSghkcLNetkobpY9pUgeqW/tQKBwQDZHHK9nDMt/zk1TxtILeUSitPXcv1/\n" \ 59 "8ufXqO0miHdH23XuXhIEA6Ef26RRVGDGgpjkveDJK/1w5feJ4H/ni4Vclil/cm38\n" \ 60 "OwRqjjd7ElHJX6JQbsxEx/gNTk5/QW1iAL9TXUalgepsSXYT6AJ0/CJv0jmJSJ36\n" \ 61 "YoKMOM8uqzb2KhN6i+RlJRi5iY53kUhWTJq5ArWvNhUzQNSYODI4bNxlsKSBL2Ik\n" \ 62 "LZ5QKHuaEjQet0IlPlfIb4PzMm8CHa/urOcCgcEA7m3zW/lL5bIFoKPjWig5Lbn1\n" \ 63 "aHfrG2ngqzWtgWtfZqMH8OkZc1Mdhhmvd46titjiLjeI+UP/uHXR0068PnrNngzl\n" \ 64 "tTgwlakzu+bWzqhBm1F+3/341st/FEk07r0P/3/PhezVjwfO8c8Exj7pLxH4wrH0\n" \ 65 "ROHgDbClmlJRu6OO78wk1+Vapf5DWa8YfA+q+fdvr7KvgGyytheKMT/b/dsqOq7y\n" \ 66 "qZPjmaJKWAvV3RWG8lWHFSdHx2IAHMHfGr17Y/w7AoHBALzwZeYebeekiVucGSjq\n" \ 67 "T8SgLhT7zCIx+JMUPjVfYzaUhP/Iu7Lkma6IzWm9nW6Drpy5pUpMzwUWDCLfzU9q\n" \ 68 "eseFIl337kEn9wLn+t5OpgAyCqYmlftxbqvdrrBN9uvnrJjWvqk/8wsDrw9JxAGc\n" \ 69 "fjeD4nBXUqvYWLXApoR9mZoGKedmoH9pFig4zlO9ig8YITnKYuQ0k6SD0b8agJHc\n" \ 70 "Ir0YSUDnRGgpjvFBGbeOCe+FGbohk/EpItJc3IAh5740lwKBwAdXd2DjokSmYKn7\n" \ 71 "oeqKxofz6+yVlLW5YuOiuX78sWlVp87xPolgi84vSEnkKM/Xsc8+goc6YstpRVa+\n" \ 72 "W+mImoA9YW1dF5HkLeWhTAf9AlgoAEIhbeIfTgBv6KNZSv7RDrDPBBxtXx/vAfSg\n" \ 73 "x0ldwk0scZsVYXLKd67yzfV7KdGUdaX4N/xYgfZm/9gCG3+q8NN2KxVHQ5F71BOE\n" \ 74 "JeABOaGo9WvnU+DNMIDZjHJMUWVw4MHz/a/UArDf/2CxaPVBNQKBwASg6j4ohSTk\n" \ 75 "J7aE6RQ3OBmmDDpixcoCJt9u9SjHVYMlbs5CEJGVSczk0SG3y8P1lOWNDSRnMksZ\n" \ 76 "xWnHdP/ogcuYMuvK7UACNAF0zNddtzOhzcpNmejFj+WCHYY/UmPr2/Kf6t7Cxk2K\n" \ 77 "3cZ4tqWsiTmBT8Bknmah7L5DrhS+ZBJliDeFAA8fZHdMH0Xjr4UBp9kF90EMTdW1\n" \ 78 "Xr5uz7ZrMsYpYQI7mmyqV9SSjUg4iBXwVSoag1iDJ1K8Qg/L7Semgg==\n" \ 79 "-----END RSA PRIVATE KEY-----\n" 80 81 /* 82 * This loads the private key we defined earlier 83 */ 84 static gnutls_x509_privkey_t test_tls_load_key(void) 85 { 86 gnutls_x509_privkey_t key; 87 const gnutls_datum_t data = { (unsigned char *)PRIVATE_KEY, 88 strlen(PRIVATE_KEY) }; 89 int err; 90 91 err = gnutls_x509_privkey_init(&key); 92 if (err < 0) { 93 g_critical("Failed to init key %s", gnutls_strerror(err)); 94 abort(); 95 } 96 97 err = gnutls_x509_privkey_import(key, &data, 98 GNUTLS_X509_FMT_PEM); 99 if (err < 0) { 100 if (err != GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR && 101 err != GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) { 102 g_critical("Failed to import key %s", gnutls_strerror(err)); 103 abort(); 104 } 105 106 err = gnutls_x509_privkey_import_pkcs8( 107 key, &data, GNUTLS_X509_FMT_PEM, NULL, 0); 108 if (err < 0) { 109 g_critical("Failed to import PKCS8 key %s", gnutls_strerror(err)); 110 abort(); 111 } 112 } 113 114 return key; 115 } 116 117 118 void test_tls_init(const char *keyfile) 119 { 120 qcrypto_init(&error_abort); 121 122 if (asn1_array2tree(pkix_asn1_tab, &pkix_asn1, NULL) != ASN1_SUCCESS) { 123 abort(); 124 } 125 126 privkey = test_tls_load_key(); 127 if (!g_file_set_contents(keyfile, PRIVATE_KEY, -1, NULL)) { 128 abort(); 129 } 130 } 131 132 133 void test_tls_cleanup(const char *keyfile) 134 { 135 asn1_delete_structure(&pkix_asn1); 136 unlink(keyfile); 137 } 138 139 /* 140 * Turns an ASN1 object into a DER encoded byte array 141 */ 142 static void test_tls_der_encode(asn1_node src, 143 const char *src_name, 144 gnutls_datum_t *res) 145 { 146 int size; 147 char *data = NULL; 148 149 size = 0; 150 asn1_der_coding(src, src_name, NULL, &size, NULL); 151 152 data = g_new0(char, size); 153 154 asn1_der_coding(src, src_name, data, &size, NULL); 155 156 res->data = (unsigned char *)data; 157 res->size = size; 158 } 159 160 161 static void 162 test_tls_get_ipaddr(const char *addrstr, 163 char **data, 164 int *datalen) 165 { 166 struct addrinfo *res; 167 struct addrinfo hints; 168 169 memset(&hints, 0, sizeof(hints)); 170 hints.ai_flags = AI_NUMERICHOST; 171 g_assert(getaddrinfo(addrstr, NULL, &hints, &res) == 0); 172 173 *datalen = res->ai_addrlen; 174 *data = g_new(char, *datalen); 175 memcpy(*data, res->ai_addr, *datalen); 176 freeaddrinfo(res); 177 } 178 179 /* 180 * This is a fairly lame x509 certificate generator. 181 * 182 * Do not copy/use this code for generating real certificates 183 * since it leaves out many things that you would want in 184 * certificates for real world usage. 185 * 186 * This is good enough only for doing tests of the QEMU 187 * TLS certificate code 188 */ 189 void 190 test_tls_generate_cert(QCryptoTLSTestCertReq *req, 191 gnutls_x509_crt_t ca) 192 { 193 gnutls_x509_crt_t crt; 194 int err; 195 static char buffer[1024 * 1024]; 196 size_t size = sizeof(buffer); 197 char serial[5] = { 1, 2, 3, 4, 0 }; 198 gnutls_datum_t der; 199 time_t start = time(NULL) + (60 * 60 * req->start_offset); 200 time_t expire = time(NULL) + (60 * 60 * (req->expire_offset 201 ? req->expire_offset : 24)); 202 203 /* 204 * Prepare our new certificate object 205 */ 206 err = gnutls_x509_crt_init(&crt); 207 if (err < 0) { 208 g_critical("Failed to initialize certificate %s", gnutls_strerror(err)); 209 abort(); 210 } 211 err = gnutls_x509_crt_set_key(crt, privkey); 212 if (err < 0) { 213 g_critical("Failed to set certificate key %s", gnutls_strerror(err)); 214 abort(); 215 } 216 217 /* 218 * A v3 certificate is required in order to be able 219 * set any of the basic constraints, key purpose and 220 * key usage data 221 */ 222 gnutls_x509_crt_set_version(crt, 3); 223 224 if (req->country) { 225 err = gnutls_x509_crt_set_dn_by_oid( 226 crt, GNUTLS_OID_X520_COUNTRY_NAME, 0, 227 req->country, strlen(req->country)); 228 if (err < 0) { 229 g_critical("Failed to set certificate country name %s", 230 gnutls_strerror(err)); 231 abort(); 232 } 233 } 234 if (req->cn) { 235 err = gnutls_x509_crt_set_dn_by_oid( 236 crt, GNUTLS_OID_X520_COMMON_NAME, 0, 237 req->cn, strlen(req->cn)); 238 if (err < 0) { 239 g_critical("Failed to set certificate common name %s", 240 gnutls_strerror(err)); 241 abort(); 242 } 243 } 244 245 /* 246 * Setup the subject altnames, which are used 247 * for hostname checks in live sessions 248 */ 249 if (req->altname1) { 250 err = gnutls_x509_crt_set_subject_alt_name( 251 crt, GNUTLS_SAN_DNSNAME, 252 req->altname1, 253 strlen(req->altname1), 254 GNUTLS_FSAN_APPEND); 255 if (err < 0) { 256 g_critical("Failed to set certificate alt name %s", 257 gnutls_strerror(err)); 258 abort(); 259 } 260 } 261 if (req->altname2) { 262 err = gnutls_x509_crt_set_subject_alt_name( 263 crt, GNUTLS_SAN_DNSNAME, 264 req->altname2, 265 strlen(req->altname2), 266 GNUTLS_FSAN_APPEND); 267 if (err < 0) { 268 g_critical("Failed to set certificate %s alt name", 269 gnutls_strerror(err)); 270 abort(); 271 } 272 } 273 274 /* 275 * IP address need to be put into the cert in their 276 * raw byte form, not strings, hence this is a little 277 * more complicated 278 */ 279 if (req->ipaddr1) { 280 char *data; 281 int len; 282 283 test_tls_get_ipaddr(req->ipaddr1, &data, &len); 284 285 err = gnutls_x509_crt_set_subject_alt_name( 286 crt, GNUTLS_SAN_IPADDRESS, 287 data, len, GNUTLS_FSAN_APPEND); 288 if (err < 0) { 289 g_critical("Failed to set certificate alt name %s", 290 gnutls_strerror(err)); 291 abort(); 292 } 293 g_free(data); 294 } 295 if (req->ipaddr2) { 296 char *data; 297 int len; 298 299 test_tls_get_ipaddr(req->ipaddr2, &data, &len); 300 301 err = gnutls_x509_crt_set_subject_alt_name( 302 crt, GNUTLS_SAN_IPADDRESS, 303 data, len, GNUTLS_FSAN_APPEND); 304 if (err < 0) { 305 g_critical("Failed to set certificate alt name %s", 306 gnutls_strerror(err)); 307 abort(); 308 } 309 g_free(data); 310 } 311 312 313 /* 314 * Basic constraints are used to decide if the cert 315 * is for a CA or not. We can't use the convenient 316 * gnutls API for setting this, since it hardcodes 317 * the 'critical' field which we want control over 318 */ 319 if (req->basicConstraintsEnable) { 320 asn1_node ext = NULL; 321 322 asn1_create_element(pkix_asn1, "PKIX1.BasicConstraints", &ext); 323 asn1_write_value(ext, "cA", 324 req->basicConstraintsIsCA ? "TRUE" : "FALSE", 1); 325 asn1_write_value(ext, "pathLenConstraint", NULL, 0); 326 test_tls_der_encode(ext, "", &der); 327 err = gnutls_x509_crt_set_extension_by_oid( 328 crt, "2.5.29.19", 329 der.data, der.size, 330 req->basicConstraintsCritical); 331 if (err < 0) { 332 g_critical("Failed to set certificate basic constraints %s", 333 gnutls_strerror(err)); 334 g_free(der.data); 335 abort(); 336 } 337 asn1_delete_structure(&ext); 338 g_free(der.data); 339 } 340 341 /* 342 * Next up the key usage extension. Again we can't 343 * use the gnutls API since it hardcodes the extension 344 * to be 'critical' 345 */ 346 if (req->keyUsageEnable) { 347 asn1_node ext = NULL; 348 char str[2]; 349 350 str[0] = req->keyUsageValue & 0xff; 351 str[1] = (req->keyUsageValue >> 8) & 0xff; 352 353 asn1_create_element(pkix_asn1, "PKIX1.KeyUsage", &ext); 354 asn1_write_value(ext, "", str, 9); 355 test_tls_der_encode(ext, "", &der); 356 err = gnutls_x509_crt_set_extension_by_oid( 357 crt, "2.5.29.15", 358 der.data, der.size, 359 req->keyUsageCritical); 360 if (err < 0) { 361 g_critical("Failed to set certificate key usage %s", 362 gnutls_strerror(err)); 363 g_free(der.data); 364 abort(); 365 } 366 asn1_delete_structure(&ext); 367 g_free(der.data); 368 } 369 370 /* 371 * Finally the key purpose extension. This time 372 * gnutls has the opposite problem, always hardcoding 373 * it to be non-critical. So once again we have to 374 * set this the hard way building up ASN1 data ourselves 375 */ 376 if (req->keyPurposeEnable) { 377 asn1_node ext = NULL; 378 379 asn1_create_element(pkix_asn1, "PKIX1.ExtKeyUsageSyntax", &ext); 380 if (req->keyPurposeOID1) { 381 asn1_write_value(ext, "", "NEW", 1); 382 asn1_write_value(ext, "?LAST", req->keyPurposeOID1, 1); 383 } 384 if (req->keyPurposeOID2) { 385 asn1_write_value(ext, "", "NEW", 1); 386 asn1_write_value(ext, "?LAST", req->keyPurposeOID2, 1); 387 } 388 test_tls_der_encode(ext, "", &der); 389 err = gnutls_x509_crt_set_extension_by_oid( 390 crt, "2.5.29.37", 391 der.data, der.size, 392 req->keyPurposeCritical); 393 if (err < 0) { 394 g_critical("Failed to set certificate key purpose %s", 395 gnutls_strerror(err)); 396 g_free(der.data); 397 abort(); 398 } 399 asn1_delete_structure(&ext); 400 g_free(der.data); 401 } 402 403 /* 404 * Any old serial number will do, so lets pick 5 405 */ 406 err = gnutls_x509_crt_set_serial(crt, serial, 5); 407 if (err < 0) { 408 g_critical("Failed to set certificate serial %s", 409 gnutls_strerror(err)); 410 abort(); 411 } 412 413 err = gnutls_x509_crt_set_activation_time(crt, start); 414 if (err < 0) { 415 g_critical("Failed to set certificate activation %s", 416 gnutls_strerror(err)); 417 abort(); 418 } 419 err = gnutls_x509_crt_set_expiration_time(crt, expire); 420 if (err < 0) { 421 g_critical("Failed to set certificate expiration %s", 422 gnutls_strerror(err)); 423 abort(); 424 } 425 426 427 /* 428 * If no 'ca' is set then we are self signing 429 * the cert. This is done for the root CA certs 430 */ 431 err = gnutls_x509_crt_sign2(crt, ca ? ca : crt, privkey, 432 GNUTLS_DIG_SHA256, 0); 433 if (err < 0) { 434 g_critical("Failed to sign certificate %s", 435 gnutls_strerror(err)); 436 abort(); 437 } 438 439 /* 440 * Finally write the new cert out to disk 441 */ 442 err = gnutls_x509_crt_export( 443 crt, GNUTLS_X509_FMT_PEM, buffer, &size); 444 if (err < 0) { 445 g_critical("Failed to export certificate %s: %d", 446 gnutls_strerror(err), err); 447 abort(); 448 } 449 450 if (!g_file_set_contents(req->filename, buffer, -1, NULL)) { 451 g_critical("Failed to write certificate %s", 452 req->filename); 453 abort(); 454 } 455 456 req->crt = crt; 457 } 458 459 460 void test_tls_write_cert_chain(const char *filename, 461 gnutls_x509_crt_t *certs, 462 size_t ncerts) 463 { 464 size_t i; 465 size_t capacity = 1024, offset = 0; 466 char *buffer = g_new0(char, capacity); 467 int err; 468 469 for (i = 0; i < ncerts; i++) { 470 size_t len = capacity - offset; 471 retry: 472 err = gnutls_x509_crt_export(certs[i], GNUTLS_X509_FMT_PEM, 473 buffer + offset, &len); 474 if (err < 0) { 475 if (err == GNUTLS_E_SHORT_MEMORY_BUFFER) { 476 buffer = g_renew(char, buffer, offset + len); 477 capacity = offset + len; 478 goto retry; 479 } 480 g_critical("Failed to export certificate chain %s: %d", 481 gnutls_strerror(err), err); 482 abort(); 483 } 484 offset += len; 485 } 486 487 if (!g_file_set_contents(filename, buffer, offset, NULL)) { 488 abort(); 489 } 490 g_free(buffer); 491 } 492 493 494 void test_tls_discard_cert(QCryptoTLSTestCertReq *req) 495 { 496 if (!req->crt) { 497 return; 498 } 499 500 gnutls_x509_crt_deinit(req->crt); 501 req->crt = NULL; 502 503 if (getenv("QEMU_TEST_DEBUG_CERTS") == NULL) { 504 unlink(req->filename); 505 } 506 } 507 508 #endif /* QCRYPTO_HAVE_TLS_TEST_SUPPORT */ 509