| /* | |
| * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>. | |
| * | |
| * This program is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU General Public License as | |
| * published by the Free Software Foundation; either version 2 of the | |
| * License, or (at your option) any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, but | |
| * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| * 02110-1301, USA. | |
| * | |
| * You can also choose to distribute this program under the terms of | |
| * the Unmodified Binary Distribution Licence (as given in the file | |
| * COPYING.UBDL), provided that you have satisfied its requirements. | |
| */ | |
| FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); | |
| #include <string.h> | |
| #include <stdio.h> | |
| #include <errno.h> | |
| #include <ipxe/refcnt.h> | |
| #include <ipxe/malloc.h> | |
| #include <ipxe/interface.h> | |
| #include <ipxe/xfer.h> | |
| #include <ipxe/open.h> | |
| #include <ipxe/iobuf.h> | |
| #include <ipxe/xferbuf.h> | |
| #include <ipxe/process.h> | |
| #include <ipxe/x509.h> | |
| #include <ipxe/settings.h> | |
| #include <ipxe/dhcp.h> | |
| #include <ipxe/base64.h> | |
| #include <ipxe/crc32.h> | |
| #include <ipxe/ocsp.h> | |
| #include <ipxe/job.h> | |
| #include <ipxe/validator.h> | |
| #include <config/crypto.h> | |
| /** @file | |
| * | |
| * Certificate validator | |
| * | |
| */ | |
| struct validator; | |
| /** A certificate validator action */ | |
| struct validator_action { | |
| /** Name */ | |
| const char *name; | |
| /** Action to take upon completed transfer */ | |
| int ( * done ) ( struct validator *validator, const void *data, | |
| size_t len ); | |
| }; | |
| /** A certificate validator */ | |
| struct validator { | |
| /** Reference count */ | |
| struct refcnt refcnt; | |
| /** Job control interface */ | |
| struct interface job; | |
| /** Data transfer interface */ | |
| struct interface xfer; | |
| /** Process */ | |
| struct process process; | |
| /** Root of trust (or NULL to use default) */ | |
| struct x509_root *root; | |
| /** X.509 certificate chain */ | |
| struct x509_chain *chain; | |
| /** OCSP check */ | |
| struct ocsp_check *ocsp; | |
| /** Data buffer */ | |
| struct xfer_buffer buffer; | |
| /** Current action */ | |
| const struct validator_action *action; | |
| /** Current certificate | |
| * | |
| * This will always be present within the certificate chain | |
| * and so this pointer does not hold a reference to the | |
| * certificate. | |
| */ | |
| struct x509_certificate *cert; | |
| }; | |
| /** | |
| * Get validator name (for debug messages) | |
| * | |
| * @v validator Certificate validator | |
| * @ret name Validator name | |
| */ | |
| static const char * validator_name ( struct validator *validator ) { | |
| /* Use name of first certificate in chain */ | |
| return x509_name ( x509_first ( validator->chain ) ); | |
| } | |
| /** | |
| * Free certificate validator | |
| * | |
| * @v refcnt Reference count | |
| */ | |
| static void validator_free ( struct refcnt *refcnt ) { | |
| struct validator *validator = | |
| container_of ( refcnt, struct validator, refcnt ); | |
| DBGC2 ( validator, "VALIDATOR %p \"%s\" freed\n", | |
| validator, validator_name ( validator ) ); | |
| x509_root_put ( validator->root ); | |
| x509_chain_put ( validator->chain ); | |
| ocsp_put ( validator->ocsp ); | |
| xferbuf_free ( &validator->buffer ); | |
| free ( validator ); | |
| } | |
| /** | |
| * Mark certificate validation as finished | |
| * | |
| * @v validator Certificate validator | |
| * @v rc Reason for finishing | |
| */ | |
| static void validator_finished ( struct validator *validator, int rc ) { | |
| /* Remove process */ | |
| process_del ( &validator->process ); | |
| /* Close all interfaces */ | |
| intf_shutdown ( &validator->xfer, rc ); | |
| intf_shutdown ( &validator->job, rc ); | |
| } | |
| /**************************************************************************** | |
| * | |
| * Job control interface | |
| * | |
| */ | |
| /** | |
| * Report job progress | |
| * | |
| * @v validator Certificate validator | |
| * @v progress Progress report to fill in | |
| * @ret ongoing_rc Ongoing job status code (if known) | |
| */ | |
| static int validator_progress ( struct validator *validator, | |
| struct job_progress *progress ) { | |
| /* Report current action, if applicable */ | |
| if ( validator->action ) { | |
| snprintf ( progress->message, sizeof ( progress->message ), | |
| "%s %s", validator->action->name, | |
| x509_name ( validator->cert ) ); | |
| } | |
| return 0; | |
| } | |
| /** Certificate validator job control interface operations */ | |
| static struct interface_operation validator_job_operations[] = { | |
| INTF_OP ( job_progress, struct validator *, validator_progress ), | |
| INTF_OP ( intf_close, struct validator *, validator_finished ), | |
| }; | |
| /** Certificate validator job control interface descriptor */ | |
| static struct interface_descriptor validator_job_desc = | |
| INTF_DESC ( struct validator, job, validator_job_operations ); | |
| /**************************************************************************** | |
| * | |
| * Cross-signing certificates | |
| * | |
| */ | |
| /** Cross-signed certificate source setting */ | |
| const struct setting crosscert_setting __setting ( SETTING_CRYPTO, crosscert )={ | |
| .name = "crosscert", | |
| .description = "Cross-signed certificate source", | |
| .tag = DHCP_EB_CROSS_CERT, | |
| .type = &setting_type_string, | |
| }; | |
| /** Default cross-signed certificate source */ | |
| static const char crosscert_default[] = CROSSCERT; | |
| /** | |
| * Append cross-signing certificates to certificate chain | |
| * | |
| * @v validator Certificate validator | |
| * @v data Raw cross-signing certificate data | |
| * @v len Length of raw data | |
| * @ret rc Return status code | |
| */ | |
| static int validator_append ( struct validator *validator, | |
| const void *data, size_t len ) { | |
| struct asn1_cursor cursor; | |
| struct x509_chain *certs; | |
| struct x509_certificate *cert; | |
| struct x509_certificate *last; | |
| int rc; | |
| /* Allocate certificate list */ | |
| certs = x509_alloc_chain(); | |
| if ( ! certs ) { | |
| rc = -ENOMEM; | |
| goto err_alloc_certs; | |
| } | |
| /* Initialise cursor */ | |
| cursor.data = data; | |
| cursor.len = len; | |
| /* Enter certificateSet */ | |
| if ( ( rc = asn1_enter ( &cursor, ASN1_SET ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not enter " | |
| "certificateSet: %s\n", validator, | |
| validator_name ( validator ), strerror ( rc ) ); | |
| goto err_certificateset; | |
| } | |
| /* Add each certificate to list */ | |
| while ( cursor.len ) { | |
| /* Add certificate to chain */ | |
| if ( ( rc = x509_append_raw ( certs, cursor.data, | |
| cursor.len ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not " | |
| "append certificate: %s\n", validator, | |
| validator_name ( validator ), strerror ( rc) ); | |
| DBGC_HDA ( validator, 0, cursor.data, cursor.len ); | |
| return rc; | |
| } | |
| cert = x509_last ( certs ); | |
| DBGC ( validator, "VALIDATOR %p \"%s\" found certificate ", | |
| validator, validator_name ( validator ) ); | |
| DBGC ( validator, "%s\n", x509_name ( cert ) ); | |
| /* Move to next certificate */ | |
| asn1_skip_any ( &cursor ); | |
| } | |
| /* Append certificates to chain */ | |
| last = x509_last ( validator->chain ); | |
| if ( ( rc = x509_auto_append ( validator->chain, certs ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not append " | |
| "certificates: %s\n", validator, | |
| validator_name ( validator ), strerror ( rc ) ); | |
| goto err_auto_append; | |
| } | |
| /* Check that at least one certificate has been added */ | |
| if ( last == x509_last ( validator->chain ) ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" failed to append any " | |
| "applicable certificates\n", validator, | |
| validator_name ( validator ) ); | |
| rc = -EACCES; | |
| goto err_no_progress; | |
| } | |
| /* Drop reference to certificate list */ | |
| x509_chain_put ( certs ); | |
| return 0; | |
| err_no_progress: | |
| err_auto_append: | |
| err_certificateset: | |
| x509_chain_put ( certs ); | |
| err_alloc_certs: | |
| return rc; | |
| } | |
| /** Cross-signing certificate download validator action */ | |
| static const struct validator_action validator_crosscert = { | |
| .name = "XCRT", | |
| .done = validator_append, | |
| }; | |
| /** | |
| * Start download of cross-signing certificate | |
| * | |
| * @v validator Certificate validator | |
| * @v cert X.509 certificate | |
| * @ret rc Return status code | |
| */ | |
| static int validator_start_download ( struct validator *validator, | |
| struct x509_certificate *cert ) { | |
| const struct asn1_cursor *issuer = &cert->issuer.raw; | |
| const char *crosscert; | |
| char *crosscert_copy; | |
| char *uri_string; | |
| size_t uri_string_len; | |
| uint32_t crc; | |
| int len; | |
| int rc; | |
| /* Determine cross-signed certificate source */ | |
| fetch_string_setting_copy ( NULL, &crosscert_setting, &crosscert_copy ); | |
| crosscert = ( crosscert_copy ? crosscert_copy : crosscert_default ); | |
| if ( ! crosscert[0] ) { | |
| rc = -EINVAL; | |
| goto err_check_uri_string; | |
| } | |
| /* Allocate URI string */ | |
| uri_string_len = ( strlen ( crosscert ) + 22 /* "/%08x.der?subject=" */ | |
| + base64_encoded_len ( issuer->len ) + 1 /* NUL */ ); | |
| uri_string = zalloc ( uri_string_len ); | |
| if ( ! uri_string ) { | |
| rc = -ENOMEM; | |
| goto err_alloc_uri_string; | |
| } | |
| /* Generate CRC32 */ | |
| crc = crc32_le ( 0xffffffffUL, issuer->data, issuer->len ); | |
| /* Generate URI string */ | |
| len = snprintf ( uri_string, uri_string_len, "%s/%08x.der?subject=", | |
| crosscert, crc ); | |
| base64_encode ( issuer->data, issuer->len, ( uri_string + len ), | |
| ( uri_string_len - len ) ); | |
| DBGC ( validator, "VALIDATOR %p \"%s\" downloading ", | |
| validator, validator_name ( validator ) ); | |
| DBGC ( validator, "\"%s\" cross-signature from %s\n", | |
| x509_name ( cert ), uri_string ); | |
| /* Set completion handler */ | |
| validator->action = &validator_crosscert; | |
| validator->cert = cert; | |
| /* Open URI */ | |
| if ( ( rc = xfer_open_uri_string ( &validator->xfer, | |
| uri_string ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not open %s: " | |
| "%s\n", validator, validator_name ( validator ), | |
| uri_string, strerror ( rc ) ); | |
| goto err_open_uri_string; | |
| } | |
| /* Success */ | |
| rc = 0; | |
| err_open_uri_string: | |
| free ( uri_string ); | |
| err_alloc_uri_string: | |
| err_check_uri_string: | |
| free ( crosscert_copy ); | |
| return rc; | |
| } | |
| /**************************************************************************** | |
| * | |
| * OCSP checks | |
| * | |
| */ | |
| /** | |
| * Validate OCSP response | |
| * | |
| * @v validator Certificate validator | |
| * @v data Raw OCSP response | |
| * @v len Length of raw data | |
| * @ret rc Return status code | |
| */ | |
| static int validator_ocsp_validate ( struct validator *validator, | |
| const void *data, size_t len ) { | |
| time_t now; | |
| int rc; | |
| /* Record OCSP response */ | |
| if ( ( rc = ocsp_response ( validator->ocsp, data, len ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not record OCSP " | |
| "response: %s\n", validator, | |
| validator_name ( validator ),strerror ( rc ) ); | |
| return rc; | |
| } | |
| /* Validate OCSP response */ | |
| now = time ( NULL ); | |
| if ( ( rc = ocsp_validate ( validator->ocsp, now ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not validate " | |
| "OCSP response: %s\n", validator, | |
| validator_name ( validator ), strerror ( rc ) ); | |
| return rc; | |
| } | |
| /* Drop reference to OCSP check */ | |
| ocsp_put ( validator->ocsp ); | |
| validator->ocsp = NULL; | |
| return 0; | |
| } | |
| /** OCSP validator action */ | |
| static const struct validator_action validator_ocsp = { | |
| .name = "OCSP", | |
| .done = validator_ocsp_validate, | |
| }; | |
| /** | |
| * Start OCSP check | |
| * | |
| * @v validator Certificate validator | |
| * @v cert Certificate to check | |
| * @v issuer Issuing certificate | |
| * @ret rc Return status code | |
| */ | |
| static int validator_start_ocsp ( struct validator *validator, | |
| struct x509_certificate *cert, | |
| struct x509_certificate *issuer ) { | |
| const char *uri_string; | |
| int rc; | |
| /* Create OCSP check */ | |
| assert ( validator->ocsp == NULL ); | |
| if ( ( rc = ocsp_check ( cert, issuer, &validator->ocsp ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not create OCSP " | |
| "check: %s\n", validator, validator_name ( validator ), | |
| strerror ( rc ) ); | |
| return rc; | |
| } | |
| /* Set completion handler */ | |
| validator->action = &validator_ocsp; | |
| validator->cert = cert; | |
| /* Open URI */ | |
| uri_string = validator->ocsp->uri_string; | |
| DBGC ( validator, "VALIDATOR %p \"%s\" checking ", | |
| validator, validator_name ( validator ) ); | |
| DBGC ( validator, "\"%s\" via %s\n", | |
| x509_name ( cert ), uri_string ); | |
| if ( ( rc = xfer_open_uri_string ( &validator->xfer, | |
| uri_string ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not open %s: " | |
| "%s\n", validator, validator_name ( validator ), | |
| uri_string, strerror ( rc ) ); | |
| return rc; | |
| } | |
| return 0; | |
| } | |
| /**************************************************************************** | |
| * | |
| * Data transfer interface | |
| * | |
| */ | |
| /** | |
| * Close data transfer interface | |
| * | |
| * @v validator Certificate validator | |
| * @v rc Reason for close | |
| */ | |
| static void validator_xfer_close ( struct validator *validator, int rc ) { | |
| /* Close data transfer interface */ | |
| intf_restart ( &validator->xfer, rc ); | |
| /* Check for errors */ | |
| if ( rc != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" transfer failed: %s\n", | |
| validator, validator_name ( validator ), | |
| strerror ( rc ) ); | |
| goto err_transfer; | |
| } | |
| DBGC2 ( validator, "VALIDATOR %p \"%s\" transfer complete\n", | |
| validator, validator_name ( validator ) ); | |
| /* Process completed download */ | |
| assert ( validator->action != NULL ); | |
| if ( ( rc = validator->action->done ( validator, validator->buffer.data, | |
| validator->buffer.len ) ) != 0 ) | |
| goto err_append; | |
| /* Free downloaded data */ | |
| xferbuf_free ( &validator->buffer ); | |
| /* Resume validation process */ | |
| process_add ( &validator->process ); | |
| return; | |
| err_append: | |
| err_transfer: | |
| validator_finished ( validator, rc ); | |
| } | |
| /** | |
| * Receive data | |
| * | |
| * @v validator Certificate validator | |
| * @v iobuf I/O buffer | |
| * @v meta Data transfer metadata | |
| * @ret rc Return status code | |
| */ | |
| static int validator_xfer_deliver ( struct validator *validator, | |
| struct io_buffer *iobuf, | |
| struct xfer_metadata *meta ) { | |
| int rc; | |
| /* Add data to buffer */ | |
| if ( ( rc = xferbuf_deliver ( &validator->buffer, iob_disown ( iobuf ), | |
| meta ) ) != 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" could not receive " | |
| "data: %s\n", validator, validator_name ( validator ), | |
| strerror ( rc ) ); | |
| validator_finished ( validator, rc ); | |
| return rc; | |
| } | |
| return 0; | |
| } | |
| /** Certificate validator data transfer interface operations */ | |
| static struct interface_operation validator_xfer_operations[] = { | |
| INTF_OP ( xfer_deliver, struct validator *, validator_xfer_deliver ), | |
| INTF_OP ( intf_close, struct validator *, validator_xfer_close ), | |
| }; | |
| /** Certificate validator data transfer interface descriptor */ | |
| static struct interface_descriptor validator_xfer_desc = | |
| INTF_DESC ( struct validator, xfer, validator_xfer_operations ); | |
| /**************************************************************************** | |
| * | |
| * Validation process | |
| * | |
| */ | |
| /** | |
| * Certificate validation process | |
| * | |
| * @v validator Certificate validator | |
| */ | |
| static void validator_step ( struct validator *validator ) { | |
| struct x509_link *link; | |
| struct x509_certificate *cert; | |
| struct x509_certificate *issuer = NULL; | |
| struct x509_certificate *last; | |
| time_t now; | |
| int rc; | |
| /* Try validating chain. Try even if the chain is incomplete, | |
| * since certificates may already have been validated | |
| * previously. | |
| */ | |
| now = time ( NULL ); | |
| if ( ( rc = x509_validate_chain ( validator->chain, now, NULL, | |
| validator->root ) ) == 0 ) { | |
| DBGC ( validator, "VALIDATOR %p \"%s\" validated\n", | |
| validator, validator_name ( validator ) ); | |
| validator_finished ( validator, 0 ); | |
| return; | |
| } | |
| /* If there is a certificate that could be validated using | |
| * OCSP, try it. | |
| */ | |
| list_for_each_entry ( link, &validator->chain->links, list ) { | |
| cert = issuer; | |
| issuer = link->cert; | |
| if ( ! cert ) | |
| continue; | |
| if ( ! x509_is_valid ( issuer, validator->root ) ) | |
| continue; | |
| /* The issuer is valid, but this certificate is not | |
| * yet valid. If OCSP is applicable, start it. | |
| */ | |
| if ( ocsp_required ( cert ) ) { | |
| /* Start OCSP */ | |
| if ( ( rc = validator_start_ocsp ( validator, cert, | |
| issuer ) ) != 0 ) { | |
| validator_finished ( validator, rc ); | |
| return; | |
| } | |
| return; | |
| } | |
| /* Otherwise, this is a permanent failure */ | |
| validator_finished ( validator, rc ); | |
| return; | |
| } | |
| /* If chain ends with a self-issued certificate, then there is | |
| * nothing more to do. | |
| */ | |
| last = x509_last ( validator->chain ); | |
| if ( asn1_compare ( &last->issuer.raw, &last->subject.raw ) == 0 ) { | |
| validator_finished ( validator, rc ); | |
| return; | |
| } | |
| /* Otherwise, try to download a suitable cross-signing | |
| * certificate. | |
| */ | |
| if ( ( rc = validator_start_download ( validator, last ) ) != 0 ) { | |
| validator_finished ( validator, rc ); | |
| return; | |
| } | |
| } | |
| /** Certificate validator process descriptor */ | |
| static struct process_descriptor validator_process_desc = | |
| PROC_DESC_ONCE ( struct validator, process, validator_step ); | |
| /**************************************************************************** | |
| * | |
| * Instantiator | |
| * | |
| */ | |
| /** | |
| * Instantiate a certificate validator | |
| * | |
| * @v job Job control interface | |
| * @v chain X.509 certificate chain | |
| * @v root Root of trust, or NULL to use default | |
| * @ret rc Return status code | |
| */ | |
| int create_validator ( struct interface *job, struct x509_chain *chain, | |
| struct x509_root *root ) { | |
| struct validator *validator; | |
| int rc; | |
| /* Sanity check */ | |
| if ( ! chain ) { | |
| rc = -EINVAL; | |
| goto err_sanity; | |
| } | |
| /* Allocate and initialise structure */ | |
| validator = zalloc ( sizeof ( *validator ) ); | |
| if ( ! validator ) { | |
| rc = -ENOMEM; | |
| goto err_alloc; | |
| } | |
| ref_init ( &validator->refcnt, validator_free ); | |
| intf_init ( &validator->job, &validator_job_desc, | |
| &validator->refcnt ); | |
| intf_init ( &validator->xfer, &validator_xfer_desc, | |
| &validator->refcnt ); | |
| process_init ( &validator->process, &validator_process_desc, | |
| &validator->refcnt ); | |
| validator->root = x509_root_get ( root ); | |
| validator->chain = x509_chain_get ( chain ); | |
| xferbuf_malloc_init ( &validator->buffer ); | |
| /* Attach parent interface, mortalise self, and return */ | |
| intf_plug_plug ( &validator->job, job ); | |
| ref_put ( &validator->refcnt ); | |
| DBGC2 ( validator, "VALIDATOR %p \"%s\" validating X509 chain %p\n", | |
| validator, validator_name ( validator ), validator->chain ); | |
| return 0; | |
| validator_finished ( validator, rc ); | |
| ref_put ( &validator->refcnt ); | |
| err_alloc: | |
| err_sanity: | |
| return rc; | |
| } |