cms.c File Reference

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

#include <stdint.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ipxe/asn1.h>
#include <ipxe/x509.h>
#include <ipxe/image.h>
#include <ipxe/malloc.h>
#include <ipxe/privkey.h>
#include <ipxe/cms.h>

Go to the source code of this file.

Macros
#define	EACCES_NON_SIGNING   __einfo_error ( EINFO_EACCES_NON_SIGNING )
#define	EINFO_EACCES_NON_SIGNING   __einfo_uniqify ( EINFO_EACCES, 0x01, "Not a signing certificate" )
#define	EACCES_NON_CODE_SIGNING   __einfo_error ( EINFO_EACCES_NON_CODE_SIGNING )
#define	EINFO_EACCES_NON_CODE_SIGNING   __einfo_uniqify ( EINFO_EACCES, 0x02, "Not a code-signing certificate" )
#define	EACCES_WRONG_NAME   __einfo_error ( EINFO_EACCES_WRONG_NAME )
#define	EINFO_EACCES_WRONG_NAME   __einfo_uniqify ( EINFO_EACCES, 0x04, "Incorrect certificate name" )
#define	EACCES_NO_SIGNATURES   __einfo_error ( EINFO_EACCES_NO_SIGNATURES )
#define	EINFO_EACCES_NO_SIGNATURES   __einfo_uniqify ( EINFO_EACCES, 0x05, "No signatures present" )
#define	EACCES_NO_RECIPIENTS   __einfo_error ( EINFO_EACCES_NO_RECIPIENTS )
#define	EINFO_EACCES_NO_RECIPIENTS   __einfo_uniqify ( EINFO_EACCES, 0x06, "No usable recipients" )
#define	EACCES_LEN   __einfo_error ( EINFO_EACCES_LEN )
#define	EINFO_EACCES_LEN   __einfo_uniqify ( EINFO_EACCES, 0x07, "Bad file length" )
#define	EACCES_PAD   __einfo_error ( EINFO_EACCES_PAD )
#define	EINFO_EACCES_PAD   __einfo_uniqify ( EINFO_EACCES, 0x08, "Bad block padding" )
#define	EACCES_MAC   __einfo_error ( EINFO_EACCES_MAC )
#define	EINFO_EACCES_MAC   __einfo_uniqify ( EINFO_EACCES, 0x09, "Invalid MAC" )
#define	ENOTSUP_TYPE   __einfo_error ( EINFO_ENOTSUP_TYPE )
#define	EINFO_ENOTSUP_TYPE   __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unrecognised message type" )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	cms_parse_signed (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS signed data. More...
static int	cms_parse_enveloped (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS enveloped data. More...
static int	cms_parse_content_type (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message content type. More...
static int	cms_parse_certificates (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message certificate list. More...
static int	cms_parse_identifier (struct cms_message *cms, struct cms_participant *part, const struct asn1_cursor *raw)
	Parse CMS message participant identifier. More...
static int	cms_parse_digest_algorithm (struct cms_message *cms, struct cms_participant *part, const struct asn1_cursor *raw)
	Parse CMS message digest algorithm. More...
static int	cms_parse_pubkey_algorithm (struct cms_message *cms, struct cms_participant *part, const struct asn1_cursor *raw)
	Parse CMS message public-key algorithm. More...
static int	cms_parse_cipher_algorithm (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message cipher algorithm. More...
static int	cms_parse_value (struct cms_message *cms, struct cms_participant *part, const struct asn1_cursor *raw)
	Parse CMS message signature or key value. More...
static int	cms_parse_participant (struct cms_message *cms, struct cms_participant *part, const struct asn1_cursor *raw)
	Parse CMS message participant information. More...
static int	cms_parse_participants (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message participants information. More...
static int	cms_parse_encrypted (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message encrypted content information. More...
static int	cms_parse_mac (struct cms_message *cms, const struct asn1_cursor *raw)
	Parse CMS message MAC. More...
static int	cms_parse (struct cms_message *cms)
	Parse CMS message from ASN.1 data. More...
static void	cms_free (struct refcnt *refcnt)
	Free CMS message. More...
int	cms_message (struct image *image, struct cms_message **cms)
	Create CMS message. More...
static void	cms_digest (struct cms_message *cms, struct cms_participant *part, const void *data, size_t len, void *out)
	Calculate digest of CMS-signed data. More...
static int	cms_verify_digest (struct cms_message *cms, struct cms_participant *part, struct x509_certificate *cert, const void *data, size_t len)
	Verify digest of CMS-signed data. More...
static int	cms_verify_signer (struct cms_message *cms, struct cms_participant *part, const void *data, size_t len, time_t time, struct x509_chain *store, struct x509_root *root)
	Verify CMS message signer. 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...
static struct cms_participant *	cms_recipient (struct cms_message *cms, struct private_key *private_key)
	Identify CMS recipient corresponding to private key. More...
static int	cms_cipher_key (struct cms_message *cms, struct cms_participant *part, struct private_key *private_key, void *ctx)
	Set CMS cipher key. More...
static int	cms_cipher (struct cms_message *cms, struct private_key *private_key, void *ctx)
	Initialise cipher for CMS decryption. More...
static int	cms_verify_padding (struct cms_message *cms, const void *data, size_t len)
	Check CMS padding. More...
int	cms_decrypt (struct cms_message *cms, struct image *image, const char *name, struct private_key *private_key)
	Decrypt CMS message. More...

Variables
static uint8_t	oid_signeddata [] = { ASN1_OID_SIGNEDDATA }
	"id-signedData" object identifier More...
static uint8_t	oid_envelopeddata [] = { ASN1_OID_ENVELOPEDDATA }
	"id-envelopedData" object identifier More...
static uint8_t	oid_authenvelopeddata [] = { ASN1_OID_AUTHENVELOPEDDATA }
	"id-authEnvelopedData" object identifier More...
static struct cms_type	cms_types []
	CMS message types. More...

Detailed Description

Cryptographic Message Syntax (PKCS #7)

The format of CMS messages is defined in RFC 5652.

Definition in file cms.c.

Macro Definition Documentation

EACCES_NON_SIGNING

#define EACCES_NON_SIGNING   __einfo_error ( EINFO_EACCES_NON_SIGNING )

Definition at line 47 of file cms.c.

EINFO_EACCES_NON_SIGNING

#define EINFO_EACCES_NON_SIGNING   __einfo_uniqify ( EINFO_EACCES, 0x01, "Not a signing certificate" )

Definition at line 49 of file cms.c.

EACCES_NON_CODE_SIGNING

#define EACCES_NON_CODE_SIGNING   __einfo_error ( EINFO_EACCES_NON_CODE_SIGNING )

Definition at line 51 of file cms.c.

EINFO_EACCES_NON_CODE_SIGNING

#define EINFO_EACCES_NON_CODE_SIGNING   __einfo_uniqify ( EINFO_EACCES, 0x02, "Not a code-signing certificate" )

Definition at line 53 of file cms.c.

EACCES_WRONG_NAME

#define EACCES_WRONG_NAME   __einfo_error ( EINFO_EACCES_WRONG_NAME )

Definition at line 55 of file cms.c.

EINFO_EACCES_WRONG_NAME

#define EINFO_EACCES_WRONG_NAME   __einfo_uniqify ( EINFO_EACCES, 0x04, "Incorrect certificate name" )

Definition at line 57 of file cms.c.

EACCES_NO_SIGNATURES

#define EACCES_NO_SIGNATURES   __einfo_error ( EINFO_EACCES_NO_SIGNATURES )

Definition at line 59 of file cms.c.

EINFO_EACCES_NO_SIGNATURES

#define EINFO_EACCES_NO_SIGNATURES   __einfo_uniqify ( EINFO_EACCES, 0x05, "No signatures present" )

Definition at line 61 of file cms.c.

EACCES_NO_RECIPIENTS

#define EACCES_NO_RECIPIENTS   __einfo_error ( EINFO_EACCES_NO_RECIPIENTS )

Definition at line 63 of file cms.c.

EINFO_EACCES_NO_RECIPIENTS

#define EINFO_EACCES_NO_RECIPIENTS   __einfo_uniqify ( EINFO_EACCES, 0x06, "No usable recipients" )

Definition at line 65 of file cms.c.

EACCES_LEN

#define EACCES_LEN   __einfo_error ( EINFO_EACCES_LEN )

Definition at line 67 of file cms.c.

EINFO_EACCES_LEN

#define EINFO_EACCES_LEN   __einfo_uniqify ( EINFO_EACCES, 0x07, "Bad file length" )

Definition at line 69 of file cms.c.

EACCES_PAD

#define EACCES_PAD   __einfo_error ( EINFO_EACCES_PAD )

Definition at line 71 of file cms.c.

EINFO_EACCES_PAD

#define EINFO_EACCES_PAD   __einfo_uniqify ( EINFO_EACCES, 0x08, "Bad block padding" )

Definition at line 73 of file cms.c.

EACCES_MAC

#define EACCES_MAC   __einfo_error ( EINFO_EACCES_MAC )

Definition at line 75 of file cms.c.

EINFO_EACCES_MAC

#define EINFO_EACCES_MAC   __einfo_uniqify ( EINFO_EACCES, 0x09, "Invalid MAC" )

Definition at line 77 of file cms.c.

ENOTSUP_TYPE

#define ENOTSUP_TYPE   __einfo_error ( EINFO_ENOTSUP_TYPE )

Definition at line 79 of file cms.c.

EINFO_ENOTSUP_TYPE

#define EINFO_ENOTSUP_TYPE   __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unrecognised message type" )

Definition at line 81 of file cms.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

cms_parse_signed()

static int cms_parse_signed ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS signed data.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 530 of file cms.c.

                                                              {
        struct asn1_cursor cursor;
        int rc;

        /* Allocate certificate list */
        cms->certificates = x509_alloc_chain();
        if ( ! cms->certificates )
                return -ENOMEM;

        /* Enter signedData */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Skip version */
        asn1_skip ( &cursor, ASN1_INTEGER );

        /* Skip digestAlgorithms */
        asn1_skip ( &cursor, ASN1_SET );

        /* Skip encapContentInfo */
        asn1_skip ( &cursor, ASN1_SEQUENCE );

        /* Parse certificates */
        if ( ( rc = cms_parse_certificates ( cms, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Skip crls, if present */
        asn1_skip_if_exists ( &cursor, ASN1_EXPLICIT_TAG ( 1 ) );

        /* Parse signerInfos */
        if ( ( rc = cms_parse_participants ( cms, &cursor ) ) != 0 )
                return rc;

        return 0;
}

References asn1_enter(), ASN1_EXPLICIT_TAG, ASN1_INTEGER, ASN1_SEQUENCE, ASN1_SET, asn1_skip(), asn1_skip_any(), asn1_skip_if_exists(), cms_message::certificates, cms_parse_certificates(), cms_parse_participants(), ENOMEM, memcpy(), raw, rc, and x509_alloc_chain().

cms_parse_enveloped()

static int cms_parse_enveloped ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS enveloped data.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 575 of file cms.c.

                                                                 {
        struct asn1_cursor cursor;
        int rc;

        /* Enter envelopedData or authEnvelopedData */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Skip version */
        asn1_skip ( &cursor, ASN1_INTEGER );

        /* Skip originatorInfo, if present */
        asn1_skip_if_exists ( &cursor, ASN1_IMPLICIT_TAG ( 0 ) );

        /* Parse recipientInfos */
        if ( ( rc = cms_parse_participants ( cms, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Parse encryptedContentInfo or authEncryptedContentInfo */
        if ( ( rc = cms_parse_encrypted ( cms, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );
        assert ( cms->cipher != NULL );

        /* Skip unprotectedAttrs or authAttrs, if present */
        asn1_skip_if_exists ( &cursor, ASN1_IMPLICIT_TAG ( 1 ) );

        /* Parse mac, if present */
        if ( ( cms->cipher->authsize != 0 ) &&
             ( ( rc = cms_parse_mac ( cms, &cursor ) ) != 0 ) )
                return rc;

        return 0;
}

References asn1_enter(), ASN1_IMPLICIT_TAG, ASN1_INTEGER, ASN1_SEQUENCE, asn1_skip(), asn1_skip_any(), asn1_skip_if_exists(), assert(), cipher_algorithm::authsize, cms_message::cipher, cms_parse_encrypted(), cms_parse_mac(), cms_parse_participants(), memcpy(), NULL, raw, and rc.

cms_parse_content_type()

static int cms_parse_content_type ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message content type.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 124 of file cms.c.

                                                                    {
        struct asn1_cursor cursor;
        struct cms_type *type;
        unsigned int i;

        /* Enter contentType */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_OID );

        /* Check for a recognised OID */
        for ( i = 0 ; i < ( sizeof ( cms_types ) /
                            sizeof ( cms_types[0] ) ) ; i++ ) {
                type = &cms_types[i];
                if ( asn1_compare ( &cursor, &type->oid ) == 0 ) {
                        cms->type = type;
                        DBGC ( cms, "CMS %p contains %sData\n",
                               cms, type->name );
                        return 0;
                }
        }

        DBGC ( cms, "CMS %p is not a recognised message type:\n", cms );
        DBGC_HDA ( cms, 0, raw->data, raw->len );
        return -ENOTSUP_TYPE;
}

References asn1_compare(), asn1_enter(), ASN1_OID, cms_types, DBGC, DBGC_HDA, ENOTSUP_TYPE, memcpy(), raw, type, and cms_message::type.

Referenced by cms_parse().

cms_parse_certificates()

static int cms_parse_certificates ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message certificate list.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 158 of file cms.c.

                                                                    {
        struct asn1_cursor cursor;
        struct x509_certificate *cert;
        int rc;

        /* Enter certificates */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_EXPLICIT_TAG ( 0 ) );

        /* Add each certificate */
        while ( cursor.len ) {

                /* Add certificate to chain */
                if ( ( rc = x509_append_raw ( cms->certificates, cursor.data,
                                              cursor.len ) ) != 0 ) {
                        DBGC ( cms, "CMS %p could not append certificate: %s\n",
                               cms, strerror ( rc) );
                        DBGC_HDA ( cms, 0, cursor.data, cursor.len );
                        return rc;
                }
                cert = x509_last ( cms->certificates );
                DBGC ( cms, "CMS %p found certificate %s\n",
                       cms, x509_name ( cert ) );

                /* Move to next certificate */
                asn1_skip_any ( &cursor );
        }

        return 0;
}

References asn1_enter(), ASN1_EXPLICIT_TAG, asn1_skip_any(), cms_message::certificates, asn1_cursor::data, DBGC, DBGC_HDA, asn1_cursor::len, memcpy(), raw, rc, strerror(), x509_append_raw(), x509_last(), and x509_name().

Referenced by cms_parse_signed().

cms_parse_identifier()

static int cms_parse_identifier ( struct cms_message *  cms, struct cms_participant *  part, const struct asn1_cursor *  raw  )

static

Parse CMS message participant identifier.

Parameters

cms	CMS message
part	Participant information to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 198 of file cms.c.

                                                                  {
        struct asn1_cursor cursor;
        struct asn1_cursor serial;
        struct asn1_cursor issuer;
        struct x509_certificate *cert;
        int rc;

        /* Enter issuerAndSerialNumber */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Identify issuer */
        memcpy ( &issuer, &cursor, sizeof ( issuer ) );
        if ( ( rc = asn1_shrink ( &issuer, ASN1_SEQUENCE ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not locate issuer: %s\n",
                       cms, part, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }
        DBGC ( cms, "CMS %p/%p issuer is:\n", cms, part );
        DBGC_HDA ( cms, 0, issuer.data, issuer.len );
        asn1_skip_any ( &cursor );

        /* Identify serialNumber */
        memcpy ( &serial, &cursor, sizeof ( serial ) );
        if ( ( rc = asn1_shrink ( &serial, ASN1_INTEGER ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not locate serialNumber: %s\n",
                       cms, part, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }
        DBGC ( cms, "CMS %p/%p serial number is:\n", cms, part );
        DBGC_HDA ( cms, 0, serial.data, serial.len );

        /* Identify certificate */
        cert = x509_find_issuer_serial ( cms->certificates, &issuer, &serial );
        if ( ! cert ) {
                DBGC ( cms, "CMS %p/%p could not identify certificate\n",
                       cms, part );
                return ( cms_is_signature ( cms ) ? -ENOENT : 0 );
        }

        /* Append certificate to chain */
        if ( ( rc = x509_append ( part->chain, cert ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not append certificate: %s\n",
                       cms, part, strerror ( rc ) );
                return rc;
        }

        /* Append remaining certificates to chain */
        if ( ( rc = x509_auto_append ( part->chain,
                                       cms->certificates ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not append certificates: %s\n",
                       cms, part, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References asn1_enter(), ASN1_INTEGER, ASN1_SEQUENCE, asn1_shrink(), asn1_skip_any(), cms_message::certificates, cms_participant::chain, cms_is_signature(), DBGC, DBGC_HDA, ENOENT, x509_certificate::issuer, memcpy(), raw, rc, serial, strerror(), x509_append(), x509_auto_append(), and x509_find_issuer_serial().

Referenced by cms_parse_participant().

cms_parse_digest_algorithm()

static int cms_parse_digest_algorithm ( struct cms_message *  cms, struct cms_participant *  part, const struct asn1_cursor *  raw  )

static

Parse CMS message digest algorithm.

Parameters

cms	CMS message
part	Participant information to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 268 of file cms.c.

                                                                        {
        struct asn1_algorithm *algorithm;
        int rc;

        /* Identify algorithm */
        if ( ( rc = asn1_digest_algorithm ( raw, &algorithm ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not identify digest algorithm: "
                       "%s\n", cms, part, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }

        /* Record digest algorithm */
        part->digest = algorithm->digest;
        DBGC ( cms, "CMS %p/%p digest algorithm is %s\n",
               cms, part, algorithm->name );

        return 0;
}

References algorithm, asn1_digest_algorithm(), DBGC, DBGC_HDA, cms_participant::digest, raw, rc, and strerror().

Referenced by cms_parse_participant().

cms_parse_pubkey_algorithm()

static int cms_parse_pubkey_algorithm ( struct cms_message *  cms, struct cms_participant *  part, const struct asn1_cursor *  raw  )

static

Parse CMS message public-key algorithm.

Parameters

cms	CMS message
part	Participant information to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 298 of file cms.c.

                                                                        {
        struct asn1_algorithm *algorithm;
        int rc;

        /* Identify algorithm */
        if ( ( rc = asn1_pubkey_algorithm ( raw, &algorithm ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not identify public-key "
                       "algorithm: %s\n", cms, part, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }

        /* Record public-key algorithm */
        part->pubkey = algorithm->pubkey;
        DBGC ( cms, "CMS %p/%p public-key algorithm is %s\n",
               cms, part, algorithm->name );

        return 0;
}

References algorithm, asn1_pubkey_algorithm(), DBGC, DBGC_HDA, cms_participant::pubkey, raw, rc, and strerror().

Referenced by cms_parse_participant().

cms_parse_cipher_algorithm()

static int cms_parse_cipher_algorithm ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message cipher algorithm.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 327 of file cms.c.

                                                                        {
        struct asn1_algorithm *algorithm;
        int rc;

        /* Identify algorithm */
        if ( ( rc = asn1_cipher_algorithm ( raw, &algorithm,
                                            &cms->iv ) ) != 0 ) {
                DBGC ( cms, "CMS %p could not identify cipher algorithm: %s\n",
                       cms, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }

        /* Record cipher */
        cms->cipher = algorithm->cipher;
        DBGC ( cms, "CMS %p cipher algorithm is %s\n", cms, algorithm->name );

        return 0;
}

References algorithm, asn1_cipher_algorithm(), cms_message::cipher, DBGC, DBGC_HDA, cms_message::iv, raw, rc, and strerror().

Referenced by cms_parse_encrypted().

cms_parse_value()

static int cms_parse_value ( struct cms_message *  cms, struct cms_participant *  part, const struct asn1_cursor *  raw  )

static

Parse CMS message signature or key value.

Parameters

cms	CMS message
part	Participant information to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 356 of file cms.c.

                                                             {
        int rc;

        /* Enter signature or encryptedKey */
        memcpy ( &part->value, raw, sizeof ( part->value ) );
        if ( ( rc = asn1_enter ( &part->value, ASN1_OCTET_STRING ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not locate value:\n",
                       cms, part );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }
        DBGC ( cms, "CMS %p/%p value is:\n", cms, part );
        DBGC_HDA ( cms, 0, part->value.data, part->value.len );

        return 0;
}

References asn1_enter(), ASN1_OCTET_STRING, asn1_cursor::data, DBGC, DBGC_HDA, asn1_cursor::len, memcpy(), raw, rc, and cms_participant::value.

Referenced by cms_parse_participant().

cms_parse_participant()

static int cms_parse_participant ( struct cms_message *  cms, struct cms_participant *  part, const struct asn1_cursor *  raw  )

static

Parse CMS message participant information.

Parameters

cms	CMS message
part	Participant information to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 383 of file cms.c.

                                                                   {
        struct asn1_cursor cursor;
        int rc;

        /* Enter signerInfo or ktri */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Skip version */
        asn1_skip ( &cursor, ASN1_INTEGER );

        /* Parse sid or rid */
        if ( ( rc = cms_parse_identifier ( cms, part, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Parse signature-only objects */
        if ( cms_is_signature ( cms ) ) {

                /* Parse digestAlgorithm */
                if ( ( rc = cms_parse_digest_algorithm ( cms, part,
                                                         &cursor ) ) != 0 )
                        return rc;
                asn1_skip_any ( &cursor );

                /* Skip signedAttrs, if present */
                asn1_skip_if_exists ( &cursor, ASN1_EXPLICIT_TAG ( 0 ) );
        }

        /* Parse signatureAlgorithm or contentEncryptionAlgorithm */
        if ( ( rc = cms_parse_pubkey_algorithm ( cms, part, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Parse signature or encryptedKey */
        if ( ( rc = cms_parse_value ( cms, part, &cursor ) ) != 0 )
                return rc;

        return 0;
}

References asn1_enter(), ASN1_EXPLICIT_TAG, ASN1_INTEGER, ASN1_SEQUENCE, asn1_skip(), asn1_skip_any(), asn1_skip_if_exists(), cms_is_signature(), cms_parse_digest_algorithm(), cms_parse_identifier(), cms_parse_pubkey_algorithm(), cms_parse_value(), memcpy(), raw, and rc.

Referenced by cms_parse_participants().

cms_parse_participants()

static int cms_parse_participants ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message participants information.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 433 of file cms.c.

                                                                    {
        struct asn1_cursor cursor;
        struct cms_participant *part;
        int rc;

        /* Enter signerInfos or recipientInfos */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SET );

        /* Add each signerInfo or recipientInfo.  Errors are handled
         * by ensuring that cms_put() will always be able to free any
         * allocated memory.
         */
        while ( cursor.len ) {

                /* Allocate participant information block */
                part = zalloc ( sizeof ( *part ) );
                if ( ! part )
                        return -ENOMEM;
                list_add ( &part->list, &cms->participants );
                part->digest = &digest_null;
                part->pubkey = &pubkey_null;

                /* Allocate certificate chain */
                part->chain = x509_alloc_chain();
                if ( ! part->chain )
                        return -ENOMEM;

                /* Parse signerInfo or recipientInfo */
                if ( ( rc = cms_parse_participant ( cms, part,
                                                    &cursor ) ) != 0 )
                        return rc;
                asn1_skip_any ( &cursor );
        }

        return 0;
}

References asn1_enter(), ASN1_SET, asn1_skip_any(), cms_participant::chain, cms_parse_participant(), cms_participant::digest, digest_null, ENOMEM, asn1_cursor::len, cms_participant::list, list_add, memcpy(), cms_message::participants, cms_participant::pubkey, pubkey_null, raw, rc, x509_alloc_chain(), and zalloc().

Referenced by cms_parse_enveloped(), and cms_parse_signed().

cms_parse_encrypted()

static int cms_parse_encrypted ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message encrypted content information.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 479 of file cms.c.

                                                                 {
        struct asn1_cursor cursor;
        int rc;

        /* Enter encryptedContentInfo */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Skip contentType */
        asn1_skip ( &cursor, ASN1_OID );

        /* Parse contentEncryptionAlgorithm */
        if ( ( rc = cms_parse_cipher_algorithm ( cms, &cursor ) ) != 0 )
                return rc;

        return 0;
}

References asn1_enter(), ASN1_OID, ASN1_SEQUENCE, asn1_skip(), cms_parse_cipher_algorithm(), memcpy(), raw, and rc.

Referenced by cms_parse_enveloped().

cms_parse_mac()

static int cms_parse_mac ( struct cms_message *  cms, const struct asn1_cursor *  raw  )

static

Parse CMS message MAC.

Parameters

cms	CMS message
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 505 of file cms.c.

                                                           {
        int rc;

        /* Enter mac */
        memcpy ( &cms->mac, raw, sizeof ( cms->mac ) );
        if ( ( rc = asn1_enter ( &cms->mac, ASN1_OCTET_STRING ) ) != 0 ) {
                DBGC ( cms, "CMS %p could not locate mac: %s\n",
                       cms, strerror ( rc ) );
                DBGC_HDA ( cms, 0, raw->data, raw->len );
                return rc;
        }
        DBGC ( cms, "CMS %p mac is:\n", cms );
        DBGC_HDA ( cms, 0, cms->mac.data, cms->mac.len );

        return 0;
}

References asn1_enter(), ASN1_OCTET_STRING, asn1_cursor::data, DBGC, DBGC_HDA, asn1_cursor::len, cms_message::mac, memcpy(), raw, rc, and strerror().

Referenced by cms_parse_enveloped().

cms_parse()

static int cms_parse ( struct cms_message *  cms )

static

Parse CMS message from ASN.1 data.

Parameters

cms	CMS message

Return values

rc	Return status code

Definition at line 618 of file cms.c.

                                                 {
        struct asn1_cursor cursor;
        int rc;

        /* Enter contentInfo */
        memcpy ( &cursor, cms->raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Parse contentType */
        if ( ( rc = cms_parse_content_type ( cms, &cursor ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Enter content */
        asn1_enter ( &cursor, ASN1_EXPLICIT_TAG ( 0 ) );

        /* Parse type-specific content */
        if ( ( rc = cms->type->parse ( cms, &cursor ) ) != 0 )
                return rc;

        return 0;
}

References asn1_enter(), ASN1_EXPLICIT_TAG, ASN1_SEQUENCE, asn1_skip_any(), cms_parse_content_type(), memcpy(), cms_type::parse, cms_message::raw, rc, and cms_message::type.

Referenced by cms_message().

cms_free()

static void cms_free ( struct refcnt *  refcnt )

static

Free CMS message.

Parameters

refcnt

Reference count

Definition at line 646 of file cms.c.

                                               {
        struct cms_message *cms =
                container_of ( refcnt, struct cms_message, refcnt );
        struct cms_participant *part;
        struct cms_participant *tmp;

        list_for_each_entry_safe ( part, tmp, &cms->participants, list ) {
                list_del ( &part->list );
                x509_chain_put ( part->chain );
                free ( part );
        }
        x509_chain_put ( cms->certificates );
        free ( cms->raw );
        free ( cms );
}

References cms_message::certificates, cms_participant::chain, container_of, free, cms_participant::list, list_del, list_for_each_entry_safe, cms_message::participants, cms_message::raw, tmp, and x509_chain_put().

Referenced by cms_message().

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 672 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_digest()

static void cms_digest ( struct cms_message *  cms, struct cms_participant *  part, const void *  data, size_t  len, void *  out  )

static

Calculate digest of CMS-signed data.

Parameters

cms	CMS message
part	Participant information
data	Signed data
len	Length of signed data
out	Digest output

Definition at line 720 of file cms.c.

                                                                   {
        struct digest_algorithm *digest = part->digest;
        uint8_t ctx[ digest->ctxsize ];

        /* Calculate digest */
        digest_init ( digest, ctx );
        digest_update ( digest, ctx, data, len );
        digest_final ( digest, ctx, out );

        DBGC ( cms, "CMS %p/%p digest value:\n", cms, part );
        DBGC_HDA ( cms, 0, out, digest->digestsize );
}

References ctx, digest_algorithm::ctxsize, data, DBGC, DBGC_HDA, cms_participant::digest, digest_final(), digest_init(), digest_update(), digest_algorithm::digestsize, len, and out.

Referenced by cms_verify_digest().

cms_verify_digest()

static int cms_verify_digest ( struct cms_message *  cms, struct cms_participant *  part, struct x509_certificate *  cert, const void *  data, size_t  len  )

static

Verify digest of CMS-signed data.

Parameters

cms	CMS message
part	Participant information
cert	Corresponding certificate
data	Signed data
len	Length of signed data

Return values

rc	Return status code

Definition at line 745 of file cms.c.

                                                              {
        struct digest_algorithm *digest = part->digest;
        struct pubkey_algorithm *pubkey = part->pubkey;
        const struct asn1_cursor *key = &cert->subject.public_key.raw;
        const struct asn1_cursor *value = &part->value;
        uint8_t digest_out[ digest->digestsize ];
        int rc;

        /* Generate digest */
        cms_digest ( cms, part, data, len, digest_out );

        /* Verify digest */
        if ( ( rc = pubkey_verify ( pubkey, key, digest, digest_out,
                                    value ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p signature verification failed: %s\n",
                       cms, part, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References cms_digest(), data, DBGC, cms_participant::digest, digest_algorithm::digestsize, key, len, cms_participant::pubkey, pubkey_verify(), x509_subject::public_key, x509_public_key::raw, rc, strerror(), x509_certificate::subject, value, and cms_participant::value.

Referenced by cms_verify_signer().

cms_verify_signer()

static int cms_verify_signer ( struct cms_message *  cms, struct cms_participant *  part, const void *  data, size_t  len, time_t  time, struct x509_chain *  store, struct x509_root *  root  )

static

Verify CMS message signer.

Parameters

cms	CMS message
part	Participant information
data	Signed data
len	Length of signed data
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 782 of file cms.c.

                                                        {
        struct x509_certificate *cert;
        int rc;

        /* Validate certificate chain */
        if ( ( rc = x509_validate_chain ( part->chain, time, store,
                                          root ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not validate chain: %s\n",
                       cms, part, strerror ( rc ) );
                return rc;
        }

        /* Extract code-signing certificate */
        cert = x509_first ( part->chain );
        assert ( cert != NULL );

        /* Check that certificate can create digital signatures */
        if ( ! ( cert->extensions.usage.bits & X509_DIGITAL_SIGNATURE ) ) {
                DBGC ( cms, "CMS %p/%p certificate cannot create signatures\n",
                       cms, part );
                return -EACCES_NON_SIGNING;
        }

        /* Check that certificate can sign code */
        if ( ! ( cert->extensions.ext_usage.bits & X509_CODE_SIGNING ) ) {
                DBGC ( cms, "CMS %p/%p certificate is not code-signing\n",
                       cms, part );
                return -EACCES_NON_CODE_SIGNING;
        }

        /* Verify digest */
        if ( ( rc = cms_verify_digest ( cms, part, cert, data, len ) ) != 0 )
                return rc;

        return 0;
}

References assert(), x509_key_usage::bits, x509_extended_key_usage::bits, cms_participant::chain, cms_verify_digest(), data, DBGC, EACCES_NON_CODE_SIGNING, EACCES_NON_SIGNING, x509_extensions::ext_usage, x509_certificate::extensions, len, NULL, rc, root, x509_certificate::store, strerror(), x509_extensions::usage, X509_CODE_SIGNING, X509_DIGITAL_SIGNATURE, x509_first(), and x509_validate_chain().

Referenced by cms_verify().

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 834 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_recipient()

static struct cms_participant* cms_recipient ( struct cms_message *  cms, struct private_key *  private_key  )

static

Identify CMS recipient corresponding to private key.

Parameters

cms	CMS message
private_key	Private key

Return values

part	Participant information, or NULL if not found

Definition at line 887 of file cms.c.

                                                                           {
        struct cms_participant *part;
        struct x509_certificate *cert;

        /* Identify certificate (if any) for which we have a private key */
        cert = x509_find_key ( NULL, private_key );
        if ( ! cert )
                return NULL;

        /* Identify corresponding recipient, if any */
        list_for_each_entry ( part, &cms->participants, list ) {
                if ( cert == x509_first ( part->chain ) )
                        return part;
        }

        return NULL;
}

References cms_participant::chain, list_for_each_entry, NULL, cms_message::participants, x509_find_key(), and x509_first().

Referenced by cms_cipher().

cms_cipher_key()

static int cms_cipher_key ( struct cms_message *  cms, struct cms_participant *  part, struct private_key *  private_key, void *  ctx  )

static

Set CMS cipher key.

Parameters

cms	CMS message
part	Participant information
private_key	Private key
ctx	Cipher context

Return values

rc	Return status code

Definition at line 914 of file cms.c.

                                                                         {
        struct cipher_algorithm *cipher = cms->cipher;
        struct pubkey_algorithm *pubkey = part->pubkey;
        const struct asn1_cursor *key = privkey_cursor ( private_key );
        const struct asn1_cursor *value = &part->value;
        struct asn1_builder cipher_key = { NULL, 0 };
        int rc;

        /* Decrypt cipher key */
        if ( ( rc = pubkey_decrypt ( pubkey, key, value,
                                     &cipher_key ) ) != 0 ) {
                DBGC ( cms, "CMS %p/%p could not decrypt cipher key: %s\n",
                       cms, part, strerror ( rc ) );
                DBGC_HDA ( cms, 0, value->data, value->len );
                goto err_decrypt;
        }
        DBGC ( cms, "CMS %p/%p cipher key:\n", cms, part );
        DBGC_HDA ( cms, 0, cipher_key.data, cipher_key.len );

        /* Set cipher key */
        if ( ( rc = cipher_setkey ( cipher, ctx, cipher_key.data,
                                    cipher_key.len ) ) != 0 ) {
                DBGC ( cms, "CMS %p could not set cipher key: %s\n",
                       cms, strerror ( rc ) );
                goto err_setkey;
        }

        /* Set cipher initialization vector */
        cipher_setiv ( cipher, ctx, cms->iv.data, cms->iv.len );
        if ( cms->iv.len ) {
                DBGC ( cms, "CMS %p cipher IV:\n", cms );
                DBGC_HDA ( cms, 0, cms->iv.data, cms->iv.len );
        }

 err_setkey:
 err_decrypt:
        free ( cipher_key.data );
        return rc;
}

References cms_message::cipher, cipher_setiv(), cipher_setkey(), ctx, asn1_cursor::data, asn1_builder::data, DBGC, DBGC_HDA, free, cms_message::iv, key, asn1_cursor::len, asn1_builder::len, NULL, privkey_cursor(), cms_participant::pubkey, pubkey_decrypt(), rc, strerror(), value, and cms_participant::value.

Referenced by cms_cipher().

cms_cipher()

static int cms_cipher ( struct cms_message *  cms, struct private_key *  private_key, void *  ctx  )

static

Initialise cipher for CMS decryption.

Parameters

cms	CMS message
private_key	Private key
ctx	Cipher context

Return values

rc	Return status code

Definition at line 964 of file cms.c.

                                                                     {
        struct cms_participant *part;
        int rc;

        /* Identify a usable recipient */
        part = cms_recipient ( cms, private_key );
        if ( ! part ) {
                DBGC ( cms, "CMS %p had no usable recipients\n", cms );
                return -EACCES_NO_RECIPIENTS;
        }

        /* Decrypt and set cipher key */
        if ( ( rc = cms_cipher_key ( cms, part, private_key, ctx ) ) != 0 )
                return rc;

        return 0;
}

References cms_cipher_key(), cms_recipient(), ctx, DBGC, EACCES_NO_RECIPIENTS, and rc.

Referenced by cms_decrypt().

cms_verify_padding()

static int cms_verify_padding ( struct cms_message *  cms, const void *  data, size_t  len  )

static

Check CMS padding.

Parameters

cms	CMS message
data	Final block
len	Final block length

Return values

len	Padding length, or negative error

Definition at line 991 of file cms.c.

                                             {
        struct cipher_algorithm *cipher = cms->cipher;
        const uint8_t *pad;
        size_t pad_len;
        unsigned int i;

        /* Non-block ciphers do not use padding */
        if ( ! is_block_cipher ( cipher ) )
                return 0;

        /* Block padding can never produce an empty file */
        if ( len == 0 ) {
                DBGC ( cms, "CMS %p invalid empty padding\n", cms );
                return -EACCES_PAD;
        }

        /* Sanity check */
        assert ( len >= cipher->blocksize );

        /* Extract and verify padding */
        pad = ( data + len - 1 );
        pad_len = *pad;
        if ( ( pad_len == 0 ) || ( pad_len > len ) ) {
                DBGC ( cms, "CMS %p invalid padding length %zd\n",
                       cms, pad_len );
                return -EACCES_PAD;
        }
        for ( i = 0 ; i < pad_len ; i++ ) {
                if ( *(pad--) != pad_len ) {
                        DBGC ( cms, "CMS %p invalid padding\n", cms );
                        DBGC_HDA ( cms, 0, ( data + len - pad_len ), pad_len );
                        return -EACCES_PAD;
                }
        }

        return pad_len;
}

References assert(), cipher_algorithm::blocksize, cms_message::cipher, data, DBGC, DBGC_HDA, EACCES_PAD, is_block_cipher(), len, pad, and pad_len.

Referenced by cms_decrypt().

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 1039 of file cms.c.

                                                                      {
        struct cipher_algorithm *cipher = cms->cipher;
        const unsigned int original_flags = image->flags;
        uint8_t ctx[ cipher->ctxsize ];
        uint8_t ctxdup[ cipher->ctxsize ];
        uint8_t auth[ cipher->authsize ];
        uint8_t final[ cipher->blocksize ];
        size_t final_len;
        size_t bulk_len;
        int pad_len;
        int rc;

        /* 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;
        }

        /* 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 all but the final block */
        final_len = ( ( image->len && is_block_cipher ( cipher ) ) ?
                      cipher->blocksize : 0 );
        bulk_len = ( image->len - final_len );
        cipher_decrypt ( cipher, ctx, image->data, image->rwdata, bulk_len );

        /* Decrypt final block */
        cipher_decrypt ( cipher, ctx, ( image->data + bulk_len ), final,
                         final_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, final, final_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.
         */
        memcpy ( ( image->rwdata + bulk_len ), final, final_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 );
        }

        return 0;

 err_set_name:
 err_pad:
 err_auth:
        /* Reencrypt all overwritten portions.  This can be done since
         * we have deliberately not overwritten the final block
         * containing the potentially invalid (and therefore
         * unreproducible) block padding.
         */
        cipher_encrypt ( cipher, ctxdup, image->data, image->rwdata, bulk_len );
        if ( original_flags & IMAGE_REGISTERED ) {
                register_image ( image ); /* Cannot fail on re-registration */
                image_put ( image );
        }
        image->flags = original_flags;
 err_cipher:
 err_blocksize:
        return rc;
}

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

Referenced by cms_decrypt_okx(), and imgdecrypt().

Variable Documentation

oid_signeddata

uint8_t oid_signeddata[] = { ASN1_OID_SIGNEDDATA }

static

"id-signedData" object identifier

Definition at line 90 of file cms.c.

oid_envelopeddata

uint8_t oid_envelopeddata[] = { ASN1_OID_ENVELOPEDDATA }

static

"id-envelopedData" object identifier

Definition at line 93 of file cms.c.

oid_authenvelopeddata

uint8_t oid_authenvelopeddata[] = { ASN1_OID_AUTHENVELOPEDDATA }

static

"id-authEnvelopedData" object identifier

Definition at line 96 of file cms.c.

cms_types

struct cms_type cms_types[]

static

Initial value:

= {
        {
                .name = "signed",
                .oid = ASN1_CURSOR ( oid_signeddata ),
                .parse = cms_parse_signed,
        },
        {
                .name = "enveloped",
                .oid = ASN1_CURSOR ( oid_envelopeddata ),
                .parse = cms_parse_enveloped,
        },
        {
                .name = "authEnveloped",
                .oid = ASN1_CURSOR ( oid_authenvelopeddata ),
                .parse = cms_parse_enveloped,
        }
}

CMS message types.

Definition at line 99 of file cms.c.

Referenced by cms_parse_content_type().