elliptic.h File Reference

Elliptic curves. More...

#include <stdint.h>
#include <ipxe/crypto.h>

Go to the source code of this file.

Macros
#define	elliptic_uncompressed_t(len)
	An uncompressed elliptic curve point.
#define	ELLIPTIC_FORMAT_UNCOMPRESSED   0x04
	Format byte for uncompressed curve point representation.
#define	ELLIPTIC_EXCHANGE(_name, _exchange, _len, _curve)
	Define an uncompressed elliptic curve point key exchange algorithm.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
int	elliptic_share (struct exchange_algorithm *exchange, const void *private, void *public)
	Share public key.
int	elliptic_agree (struct exchange_algorithm *exchange, const void *private, const void *partner, void *shared)
	Agree shared secret.

Detailed Description

Elliptic curves.

Definition in file elliptic.h.

Macro Definition Documentation

elliptic_uncompressed_t

#define elliptic_uncompressed_t

(

len

)

Value:

struct {                                                        \
        uint8_t format;                                         \
        union {                                                 \
                struct {                                        \
                        uint8_t x[ (len) ];                     \
                        uint8_t y[ (len) ];                     \
                } __attribute__ (( packed ));                   \
                uint8_t xy[ (len) * 2 ];                        \
        };                                                      \
} __attribute__ (( packed ))

An uncompressed elliptic curve point.

Definition at line 17 of file elliptic.h.

#define elliptic_uncompressed_t( len )                                  \
        struct {                                                        \
                uint8_t format;                                         \
                union {                                                 \
                        struct {                                        \
                                uint8_t x[ (len) ];                     \
                                uint8_t y[ (len) ];                     \
                        } __attribute__ (( packed ));                   \
                        uint8_t xy[ (len) * 2 ];                        \
                };                                                      \
        } __attribute__ (( packed ))

Referenced by elliptic_agree(), and elliptic_share().

ELLIPTIC_FORMAT_UNCOMPRESSED

#define ELLIPTIC_FORMAT_UNCOMPRESSED   0x04

Format byte for uncompressed curve point representation.

Definition at line 30 of file elliptic.h.

Referenced by elliptic_agree(), and elliptic_share().

ELLIPTIC_EXCHANGE

#define ELLIPTIC_EXCHANGE	(		_name,
			_exchange,
			_len,
			_curve )

Value:

struct exchange_algorithm _exchange = {                         \
        .name = #_name,                                         \
        .privsize = (_len),                                     \
        .pubsize = sizeof ( elliptic_uncompressed_t (_len) ),   \
        .sharedsize = (_len),                                   \
        .share = elliptic_share,                                \
        .agree = elliptic_agree,                                \
        .priv = _curve,                                         \
}

Define an uncompressed elliptic curve point key exchange algorithm.

Definition at line 39 of file elliptic.h.

#define ELLIPTIC_EXCHANGE( _name, _exchange, _len, _curve )             \
        struct exchange_algorithm _exchange = {                         \
                .name = #_name,                                         \
                .privsize = (_len),                                     \
                .pubsize = sizeof ( elliptic_uncompressed_t (_len) ),   \
                .sharedsize = (_len),                                   \
                .share = elliptic_share,                                \
                .agree = elliptic_agree,                                \
                .priv = _curve,                                         \
        }

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

elliptic_share()

int elliptic_share ( struct exchange_algorithm * exchange, const void * private, void * public )

extern

Share public key.

Parameters

exchange	Key exchange algorithm
private	Private key
public	Public key to fill in

Return values

rc	Return status code

Definition at line 47 of file elliptic.c.

                                     {
        struct elliptic_curve *curve = exchange->priv;
        size_t len = exchange->sharedsize;
        elliptic_uncompressed_t ( len ) *result = public;
        int rc;
 
        /* Sanity checks */
        assert ( curve->keysize == exchange->privsize );
        assert ( curve->pointsize == sizeof ( result->xy ) );
        assert ( sizeof ( *result ) == exchange->pubsize );
 
        /* Calculate public key */
        result->format = ELLIPTIC_FORMAT_UNCOMPRESSED;
        if ( ( rc = elliptic_multiply ( curve, curve->base, private,
                                        &result->xy ) ) != 0 ) {
                /* Can never fail when using the curve's own base point */
                assert ( 0 );
                return rc;
        }
 
        return rc;
}

References assert, elliptic_curve::base, ELLIPTIC_FORMAT_UNCOMPRESSED, elliptic_multiply(), elliptic_uncompressed_t, elliptic_curve::keysize, len, elliptic_curve::pointsize, exchange_algorithm::priv, exchange_algorithm::privsize, exchange_algorithm::pubsize, rc, result, and exchange_algorithm::sharedsize.

elliptic_agree()

int elliptic_agree ( struct exchange_algorithm * exchange, const void * private, const void * partner, void * shared )

extern

Agree shared secret.

Parameters

exchange	Key exchange algorithm
private	Private key
partner	Partner public key
shared	Shared secret to fill in

Return values

rc	Return status code

Definition at line 80 of file elliptic.c.

                                                         {
        struct elliptic_curve *curve = exchange->priv;
        size_t len = exchange->sharedsize;
        const elliptic_uncompressed_t ( len ) *base = partner;
        elliptic_uncompressed_t ( len ) result;
        int rc;
 
        /* Sanity checks */
        assert ( curve->keysize == exchange->privsize );
        assert ( curve->pointsize == sizeof ( base->xy ) );
        assert ( curve->pointsize == sizeof ( result.xy ) );
        assert ( sizeof ( *base ) == exchange->pubsize );
        assert ( sizeof ( result.x ) == exchange->sharedsize );
 
        /* Calculate shared secret */
        if ( ( rc = elliptic_multiply ( curve, &base->xy, private,
                                        result.xy ) ) != 0 )
                return rc;
        memcpy ( shared, &result.x, sizeof ( result.x ) );
 
        /* Check for point at infinity */
        if ( elliptic_is_infinity ( curve, &result.xy ) )
                return -EPERM;
 
        /* Check format byte */
        if ( base->format != ELLIPTIC_FORMAT_UNCOMPRESSED )
                return -EPERM;
 
        return 0;
}

References assert, base, ELLIPTIC_FORMAT_UNCOMPRESSED, elliptic_is_infinity(), elliptic_multiply(), elliptic_uncompressed_t, EPERM, elliptic_curve::keysize, len, memcpy(), partner, elliptic_curve::pointsize, exchange_algorithm::priv, exchange_algorithm::privsize, exchange_algorithm::pubsize, rc, result, and exchange_algorithm::sharedsize.