pem.c File Reference

PEM-encoded ASN.1 data. More...

#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/asn1.h>
#include <ipxe/base64.h>
#include <ipxe/image.h>
#include <ipxe/pem.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static size_t	pem_next (const void *data, size_t len, size_t offset)
	Locate next line.
static int	pem_marker (const void *data, size_t len, size_t offset, const char *marker)
	Locate boundary marker line.
int	pem_asn1 (const void *data, size_t len, size_t offset, struct asn1_cursor **cursor)
	Extract ASN.1 object from PEM data.
static int	pem_image_probe (struct image *image)
	Probe PEM image.
static int	pem_image_asn1 (struct image *image, size_t offset, struct asn1_cursor **cursor)
	Extract ASN.1 object from image.
struct image_type pem_image_type	__image_type (PROBE_NORMAL)
	PEM image type.

Detailed Description

PEM-encoded ASN.1 data.

Definition in file pem.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

pem_next()

size_t pem_next ( const void * data, size_t len, size_t offset )

static

Locate next line.

Parameters

data	PEM data
len	Length of PEM data
offset	Starting offset

Return values

next	Offset to next line

Definition at line 49 of file pem.c.

                                                                       {
        const void *sep;
 
        /* Find and skip next newline character, if any */
        sep = memchr ( ( data + offset ), '\n', ( len - offset ) );
        if ( ! sep )
                return len;
        return ( ( sep - data ) + 1 );
}

References data, len, memchr(), and offset.

Referenced by pem_asn1(), and pem_marker().

pem_marker()

int pem_marker ( const void * data, size_t len, size_t offset, const char * marker )

static

Locate boundary marker line.

Parameters

data	PEM data
len	Length of PEM data
offset	Starting offset
marker	Boundary marker

Return values

offset

Offset to boundary marker line, or negative error

Definition at line 68 of file pem.c.

                                             {
        size_t marker_len = strlen ( marker );
 
        /* Sanity check */
        assert ( offset <= len );
 
        /* Scan for marker at start of line */
        while ( offset < len ) {
 
                /* Check for marker */
                if ( ( len - offset ) < marker_len )
                        break;
                if ( memcmp ( ( data + offset ), marker, marker_len ) == 0 )
                        return offset;
 
                /* Move to next line */
                offset = pem_next ( data, len, offset );
                assert ( offset <= len );
        }
 
        return -ENOENT;
}

References assert, data, ENOENT, len, marker, memcmp(), offset, pem_next(), and strlen().

Referenced by pem_asn1(), and pem_image_probe().

pem_asn1()

int pem_asn1	(	const void *	data,
		size_t	len,
		size_t	offset,
		struct asn1_cursor **	cursor )

Extract ASN.1 object from PEM data.

Parameters

data	PEM data
len	Length of PEM data
offset	Offset within data
cursor	ASN.1 cursor to fill in

Return values

next	Offset to next object, or negative error

The caller is responsible for eventually calling free() on the allocated ASN.1 cursor.

Definition at line 104 of file pem.c.

                                             {
        size_t encoded_len;
        size_t decoded_max_len;
        char *encoded;
        void *decoded;
        int decoded_len;
        int begin;
        int end;
        int rc;
 
        /* Locate and skip BEGIN marker */
        begin = pem_marker ( data, len, offset, PEM_BEGIN );
        if ( begin < 0 ) {
                rc = begin;
                DBGC ( data, "PEM [%#zx,%#zx) missing BEGIN marker: %s\n",
                       offset, len, strerror ( rc ) );
                goto err_begin;
        }
        begin = pem_next ( data, len, begin );
 
        /* Locate and skip END marker */
        end = pem_marker ( data, len, begin, PEM_END );
        if ( end < 0 ) {
                rc = end;
                DBGC ( data, "PEM [%#zx,%#zx) missing END marker: %s\n",
                       offset, len, strerror ( rc ) );
                goto err_end;
        }
        encoded_len = ( end - begin );
        end = pem_next ( data, len, end );
 
        /* Extract Base64-encoded data */
        encoded = malloc ( encoded_len + 1 /* NUL */ );
        if ( ! encoded ) {
                rc = -ENOMEM;
                goto err_alloc_encoded;
        }
        memcpy ( encoded, ( data + begin ), encoded_len );
        encoded[encoded_len] = '\0';
 
        /* Allocate cursor and data buffer */
        decoded_max_len = base64_decoded_max_len ( encoded );
        *cursor = malloc ( sizeof ( **cursor ) + decoded_max_len );
        if ( ! *cursor ) {
                rc = -ENOMEM;
                goto err_alloc_cursor;
        }
        decoded = ( ( ( void * ) *cursor ) + sizeof ( **cursor ) );
 
        /* Decode Base64-encoded data */
        decoded_len = base64_decode ( encoded, decoded, decoded_max_len );
        if ( decoded_len < 0 ) {
                rc = decoded_len;
                DBGC ( data, "PEM could not decode: %s\n", strerror ( rc ) );
                goto err_decode;
        }
        (*cursor)->data = decoded;
        (*cursor)->len = decoded_len;
        assert ( (*cursor)->len <= decoded_max_len );
 
        /* Free Base64-encoded data */
        free ( encoded );
 
        /* Update offset and skip any unencapsulated trailer */
        offset = end;
        if ( pem_marker ( data, len, offset, PEM_BEGIN ) < 0 )
                offset = len;
 
        return offset;
 
 err_decode:
        free ( *cursor );
        *cursor = NULL;
 err_alloc_cursor:
        free ( encoded );
 err_alloc_encoded:
 err_end:
 err_begin:
        return rc;
}

References assert, base64_decode(), base64_decoded_max_len(), data, DBGC, end, ENOMEM, free, len, malloc(), memcpy(), NULL, offset, PEM_BEGIN, PEM_END, pem_marker(), pem_next(), rc, and strerror().

Referenced by efisig_asn1(), ipair_rx_pubkey(), and pem_image_asn1().

pem_image_probe()

int pem_image_probe ( struct image * image )

static

Probe PEM image.

Parameters

image

PEM image

Return values

rc	Return status code

Definition at line 192 of file pem.c.

                                                   {
        int offset;
        int rc;
 
        /* Check that image contains a BEGIN marker */
        if ( ( offset = pem_marker ( image->data, image->len, 0,
                                     PEM_BEGIN ) ) < 0 ) {
                rc = offset;
                DBGC ( image, "PEM %s has no BEGIN marker: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References image::data, DBGC, image::len, image::name, offset, PEM_BEGIN, pem_marker(), rc, and strerror().

Referenced by __image_type().

pem_image_asn1()

int pem_image_asn1 ( struct image * image, size_t offset, struct asn1_cursor ** cursor )

static

Extract ASN.1 object from image.

Parameters

image	PEM image
offset	Offset within image
cursor	ASN.1 cursor to fill in

Return values

next	Offset to next image, or negative error

The caller is responsible for eventually calling free() on the allocated ASN.1 cursor.

Definition at line 219 of file pem.c.

                                                          {
        int next;
        int rc;
 
        /* Extract ASN.1 object */
        if ( ( next = pem_asn1 ( image->data, image->len, offset,
                                 cursor ) ) < 0 ) {
                rc = next;
                DBGC ( image, "PEM %s could not extract ASN.1: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        return next;
}

References image::data, DBGC, image::len, image::name, next, offset, pem_asn1(), rc, and strerror().

Referenced by __image_type().

__image_type()

struct image_type pem_image_type __image_type

(

PROBE_NORMAL

)

PEM image type.

References __image_type, pem_image_asn1(), pem_image_probe(), and PROBE_NORMAL.