cms.h File Reference

Cryptographic Message Syntax (PKCS #7) More...

#include <time.h>
#include <ipxe/asn1.h>
#include <ipxe/crypto.h>
#include <ipxe/x509.h>
#include <ipxe/refcnt.h>
#include <ipxe/uaccess.h>

Go to the source code of this file.

Data Structures
struct	cms_type
	A CMS message type. More...
struct	cms_participant
	CMS participant information. More...
struct	cms_message
	A CMS message. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static struct cms_message *	cms_get (struct cms_message *cms)
	Get reference to CMS message. More...
static void	cms_put (struct cms_message *cms)
	Drop reference to CMS message. More...
static int	cms_is_signature (struct cms_message *cms)
	Check if CMS message is a signature message. More...
static int	cms_is_encrypted (struct cms_message *cms)
	Check if CMS message is an encrypted message. More...
int	cms_message (struct image *image, struct cms_message **cms)
	Create CMS message. More...
int	cms_verify (struct cms_message *cms, struct image *image, const char *name, time_t time, struct x509_chain *store, struct x509_root *root)
	Verify CMS signature. More...
int	cms_decrypt (struct cms_message *cms, struct image *image, const char *name, struct private_key *private_key)
	Decrypt CMS message. More...

Detailed Description

Cryptographic Message Syntax (PKCS #7)

Definition in file cms.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

cms_get()

static struct cms_message* cms_get ( struct cms_message *  cms )

inlinestatic

Get reference to CMS message.

Parameters

cms	CMS message

Return values

cms	CMS message

Definition at line 83 of file cms.h.

                                    {
        ref_get ( &cms->refcnt );
        return cms;
}

References ref_get, and cms_message::refcnt.

cms_put()

static void cms_put ( struct cms_message *  cms )

inlinestatic

Drop reference to CMS message.

Parameters

cms	CMS message

Definition at line 94 of file cms.h.

                                    {
        ref_put ( &cms->refcnt );
}

References ref_put, and cms_message::refcnt.

Referenced by cms_message(), cms_test_exec(), imgdecrypt(), and imgverify().

cms_is_signature()

static int cms_is_signature ( struct cms_message *  cms )

inlinestatic

Check if CMS message is a signature message.

Parameters

cms	CMS message

Return values

is_signature

Message is a signature message

Definition at line 105 of file cms.h.

                                             {

        /* CMS signatures include an optional CertificateSet */
        return ( cms->certificates != NULL );
}

References cms_message::certificates, and NULL.

Referenced by cms_parse_identifier(), cms_parse_participant(), and cms_verify().

cms_is_encrypted()

static int cms_is_encrypted ( struct cms_message *  cms )

inlinestatic

Check if CMS message is an encrypted message.

Parameters

cms	CMS message

Return values

is_encrypted

Message is an encrypted message

Definition at line 118 of file cms.h.

                                             {

        /* CMS encrypted messages have a cipher algorithm */
        return ( cms->cipher != NULL );
}

References cms_message::cipher, and NULL.

cms_message()

int cms_message	(	struct image *	image,
		struct cms_message **	cms
	)

Create CMS message.

Parameters

image

Image

Return values

sig	CMS message
rc	Return status code

On success, the caller holds a reference to the CMS message, and is responsible for ultimately calling cms_put().

Definition at line 677 of file cms.c.

                                                                  {
        int next;
        int rc;

        /* Allocate and initialise message */
        *cms = zalloc ( sizeof ( **cms ) );
        if ( ! *cms ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        ref_init ( &(*cms)->refcnt, cms_free );
        INIT_LIST_HEAD ( &(*cms)->participants );
        (*cms)->cipher = &cipher_null;

        /* Get raw message data */
        next = image_asn1 ( image, 0, &(*cms)->raw );
        if ( next < 0 ) {
                rc = next;
                DBGC ( *cms, "CMS %p could not get raw ASN.1 data: %s\n",
                       *cms, strerror ( rc ) );
                goto err_asn1;
        }

        /* Use only first message in image */
        asn1_shrink_any ( (*cms)->raw );

        /* Parse message */
        if ( ( rc = cms_parse ( *cms ) ) != 0 )
                goto err_parse;

        return 0;

 err_parse:
 err_asn1:
        cms_put ( *cms );
 err_alloc:
        return rc;
}

References asn1_shrink_any(), cipher_null, cms_free(), cms_parse(), cms_put(), DBGC, ENOMEM, image_asn1(), INIT_LIST_HEAD, next, rc, ref_init, strerror(), and zalloc().

cms_verify()

int cms_verify	(	struct cms_message *	cms,
		struct image *	image,
		const char *	name,
		time_t	time,
		struct x509_chain *	store,
		struct x509_root *	root
	)

Verify CMS signature.

Parameters

cms	CMS message
image	Signed image
name	Required common name, or NULL to check all signatures
time	Time at which to validate certificates
store	Certificate store, or NULL to use default
root	Root certificate list, or NULL to use default

Return values

rc	Return status code

Definition at line 854 of file cms.c.

                                          {
        struct cms_participant *part;
        struct x509_certificate *cert;
        int count = 0;
        int rc;

        /* Mark image as untrusted */
        image_untrust ( image );

        /* Sanity check */
        if ( ! cms_is_signature ( cms ) )
                return -ENOTTY;

        /* Verify using all signers */
        list_for_each_entry ( part, &cms->participants, list ) {
                cert = x509_first ( part->chain );
                if ( name && ( x509_check_name ( cert, name ) != 0 ) )
                        continue;
                if ( ( rc = cms_verify_signer ( cms, part, image->data,
                                                image->len, time, store,
                                                root ) ) != 0 )
                        return rc;
                count++;
        }

        /* Check that we have verified at least one signature */
        if ( count == 0 ) {
                if ( name ) {
                        DBGC ( cms, "CMS %p had no signatures matching name "
                               "%s\n", cms, name );
                        return -EACCES_WRONG_NAME;
                } else {
                        DBGC ( cms, "CMS %p had no signatures\n", cms );
                        return -EACCES_NO_SIGNATURES;
                }
        }

        /* Mark image as trusted */
        image_trust ( image );

        return 0;
}

References cms_participant::chain, cms_is_signature(), cms_verify_signer(), count, image::data, DBGC, EACCES_NO_SIGNATURES, EACCES_WRONG_NAME, ENOTTY, image_trust(), image_untrust(), image::len, list_for_each_entry, name, cms_message::participants, rc, root, x509_certificate::store, x509_check_name(), and x509_first().

Referenced by cms_verify_fail_okx(), cms_verify_okx(), and imgverify().

cms_decrypt()

int cms_decrypt	(	struct cms_message *	cms,
		struct image *	image,
		const char *	name,
		struct private_key *	private_key
	)

Decrypt CMS message.

Parameters

cms	CMS message
image	Image to decrypt
name	Decrypted image name, or NULL to use default
private_key	Private key

Return values

rc	Return status code

Definition at line 1059 of file cms.c.

                                                                      {
        struct cipher_algorithm *cipher = cms->cipher;
        const unsigned int original_flags = image->flags;
        size_t offset;
        size_t remaining;
        size_t frag_len;
        int pad_len;
        void *tmp;
        void *ctx;
        void *ctxdup;
        void *auth;
        int rc;

        /* Sanity checks */
        if ( ! cipher ) {
                rc = -ENOTTY;
                goto err_no_cipher;
        }

        /* Check block size */
        if ( ( image->len & ( cipher->blocksize - 1 ) ) != 0 ) {
                DBGC ( cms, "CMS %p invalid length %zd\n", cms, image->len );
                rc = -EACCES_LEN;
                goto err_blocksize;
        }

        /* Allocate temporary working space */
        tmp = malloc ( CMS_DECRYPT_BLKSZ + ( 2 * cipher->ctxsize ) +
                       cipher->authsize );
        if ( ! tmp ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        ctx = ( tmp + CMS_DECRYPT_BLKSZ );
        ctxdup = ( ctx + cipher->ctxsize );
        auth = ( ctxdup + cipher->ctxsize );

        /* Initialise cipher */
        if ( ( rc = cms_cipher ( cms, private_key, ctx ) ) != 0 )
                goto err_cipher;

        /* Duplicate cipher context for potential reencryption on error */
        memcpy ( ctxdup, ctx, cipher->ctxsize );

        /* Clear trusted flag before modifying image */
        image_untrust ( image );

        /* Temporarily unregister image, if applicable */
        if ( original_flags & IMAGE_REGISTERED ) {
                image_get ( image );
                unregister_image ( image );
        }

        /* Decrypt one block at a time */
        offset = 0;
        remaining = image->len;
        frag_len = 0;
        while ( remaining ) {

                /* Calculate fragment length */
                frag_len = remaining;
                if ( frag_len > CMS_DECRYPT_BLKSZ )
                        frag_len = CMS_DECRYPT_BLKSZ;

                /* Decrypt fragment */
                copy_from_user ( tmp, image->data, offset, frag_len );
                cipher_decrypt ( cipher, ctx, tmp, tmp, frag_len );

                /* Overwrite all but the final fragment */
                if ( remaining > frag_len )
                        copy_to_user ( image->data, offset, tmp, frag_len );

                /* Move to next block */
                remaining -= frag_len;
                offset += frag_len;
        }

        /* Check authentication tag, if applicable */
        cipher_auth ( cipher, ctx, auth );
        if ( ( cms->mac.len != cipher->authsize ) ||
             ( memcmp ( cms->mac.data, auth, cipher->authsize ) != 0 ) ) {
                DBGC ( cms, "CMS %p invalid authentication tag\n", cms );
                DBGC_HDA ( cms, 0, auth, cipher->authsize );
                rc = -EACCES_MAC;
                goto err_auth;
        }

        /* Check block padding, if applicable */
        if ( ( pad_len = cms_verify_padding ( cms, tmp, frag_len ) ) < 0 ) {
                rc = pad_len;
                goto err_pad;
        }

        /* Update image name. Do this as the last possible failure, so
         * that we do not have to include any error-handling code path
         * to restore the original image name (which may itself fail).
         */
        if ( name ) {
                if ( ( rc = image_set_name ( image, name ) ) != 0 )
                        goto err_set_name;
        } else {
                image_strip_suffix ( image );
        }

        /* Overwrite final fragment and strip block padding.  Do this
         * only once no further failure paths exist, so that we do not
         * have to include include any error-handling code path to
         * reconstruct the block padding.
         */
        copy_to_user ( image->data, ( offset - frag_len ), tmp, frag_len );
        image->len -= pad_len;

        /* Clear image type and re-register image, if applicable */
        image->type = NULL;
        if ( original_flags & IMAGE_REGISTERED ) {
                register_image ( image );
                image_put ( image );
        }

        /* Free temporary working space */
        free ( tmp );

        return 0;

 err_set_name:
 err_pad:
 err_auth:
        /* Reencrypt all overwritten fragments.  This can be done
         * since we have deliberately not overwritten the final
         * fragment containing the potentially invalid (and therefore
         * unreproducible) block padding.
         */
        remaining = ( offset - frag_len );
        for ( offset = 0 ; offset < remaining ; offset += CMS_DECRYPT_BLKSZ ) {
                copy_from_user ( tmp, image->data, offset, CMS_DECRYPT_BLKSZ );
                cipher_encrypt ( cipher, ctxdup, tmp, tmp, CMS_DECRYPT_BLKSZ );
                copy_to_user ( image->data, offset, tmp, CMS_DECRYPT_BLKSZ );
        }
        if ( original_flags & IMAGE_REGISTERED ) {
                register_image ( image ); /* Cannot fail on re-registration */
                image_put ( image );
        }
        image->flags = original_flags;
 err_cipher:
        free ( tmp );
 err_alloc:
 err_blocksize:
 err_no_cipher:
        return rc;
}

References cipher_algorithm::auth, cipher_algorithm::authsize, cipher_algorithm::blocksize, cms_message::cipher, cipher_auth(), cipher_decrypt, cipher_encrypt, cms_cipher(), CMS_DECRYPT_BLKSZ, cms_verify_padding(), copy_from_user(), copy_to_user(), ctx, cipher_algorithm::ctxsize, asn1_cursor::data, image::data, DBGC, DBGC_HDA, EACCES_LEN, EACCES_MAC, ENOMEM, ENOTTY, image::flags, free, image_get(), image_put(), IMAGE_REGISTERED, image_set_name(), image_strip_suffix(), image_untrust(), asn1_cursor::len, image::len, cms_message::mac, malloc(), memcmp(), memcpy(), name, NULL, offset, pad_len, rc, register_image(), tmp, image::type, and unregister_image().

Referenced by cms_decrypt_okx(), and imgdecrypt().