HKDF self-tests. More...

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

Data Structures
struct	hkdf_test
	An HKDF self-test. More...

Macros
#define	IKM(...)
	Define inline input keying material.
#define	SALT(...)
	Define inline salt.
#define	INFO(...)
	Define inline additional information.
#define	PRK(...)
	Define inline expected pseudorandom key.
#define	PRK_UNSPECIFIED PRK()
	Define inline absence of expected pseudorandom key.
#define	OKM(...)
	Define inline expected output keying material.
#define	HKDF_TEST(name, DIGEST, SALTED, IKM, SALT, INFO, PRK, OKM)
	Define an HKDF test.
#define	hkdf_ok(test)
	Report an HKDF test result.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
void	hkdf_okx (struct hkdf_test test, const char file, unsigned int line)
	Report an HKDF test result.

Detailed Description

HKDF self-tests.

Definition in file hkdf_test.h.

Macro Definition Documentation

◆ IKM

#define IKM ( ... )

Value:

{ __VA_ARGS__ }

Define inline input keying material.

Definition at line 17 of file hkdf_test.h.

◆ SALT

#define SALT ( ... )

Value:

{ __VA_ARGS__ }

Define inline salt.

Definition at line 20 of file hkdf_test.h.

◆ INFO

#define INFO ( ... )

Value:

{ __VA_ARGS__ }

Define inline additional information.

Definition at line 23 of file hkdf_test.h.

◆ PRK

#define PRK ( ... )

Value:

{ __VA_ARGS__ }

Define inline expected pseudorandom key.

Definition at line 26 of file hkdf_test.h.

Referenced by HKDF_TEST(), HKDF_TEST(), HKDF_TEST(), HKDF_TEST(), HKDF_TEST(), HKDF_TEST(), and HKDF_TEST().

◆ PRK_UNSPECIFIED

#define PRK_UNSPECIFIED PRK()

Define inline absence of expected pseudorandom key.

Definition at line 29 of file hkdf_test.h.

◆ OKM

#define OKM ( ... )

Value:

{ __VA_ARGS__ }

Define inline expected output keying material.

Definition at line 32 of file hkdf_test.h.

◆ HKDF_TEST

#define HKDF_TEST	(	name,
		DIGEST,
		SALTED,
		IKM,
		SALT,
		INFO,
		PRK,
		OKM )

Value:

static const uint8_t name ## _ikm[] = IKM;                      \
static const uint8_t name ## _salt[] = SALT;                    \
static const uint8_t name ## _info[] = INFO;                    \
static const uint8_t name ## _prk[] = PRK;                      \
static const uint8_t name ## _okm[] = OKM;                      \
static struct hkdf_test name = {                                \
        .digest = DIGEST,                                       \
        .ikm = name ## _ikm,                                    \
        .ikm_len = sizeof ( name ## _ikm ),                     \
        .salt = ( SALTED ? name ## _salt : NULL ),              \
        .salt_len = sizeof ( name ## _salt ),                   \
        .info = name ## _info,                                  \
        .info_len = sizeof ( name ## _info ),                   \
        .prk = name ## _prk,                                    \
        .prk_len = sizeof ( name ## _prk ),                     \
        .okm = name ## _okm,                                    \
        .okm_len = sizeof ( name ## _okm ),                     \
}

Define an HKDF test.

Parameters

name	Test name
DIGEST	Digest algorithm
SALTED	Use salt value
IKM	Input keying material
SALT	Salt
INFO	Additional information
PRK	Expected pseudorandom key
OKM	Expected output keying material

Definition at line 72 of file hkdf_test.h.

#define HKDF_TEST( name, DIGEST, SALTED, IKM, SALT, INFO, PRK, OKM )    \
        static const uint8_t name ## _ikm[] = IKM;                      \
        static const uint8_t name ## _salt[] = SALT;                    \
        static const uint8_t name ## _info[] = INFO;                    \
        static const uint8_t name ## _prk[] = PRK;                      \
        static const uint8_t name ## _okm[] = OKM;                      \
        static struct hkdf_test name = {                                \
                .digest = DIGEST,                                       \
                .ikm = name ## _ikm,                                    \
                .ikm_len = sizeof ( name ## _ikm ),                     \
                .salt = ( SALTED ? name ## _salt : NULL ),              \
                .salt_len = sizeof ( name ## _salt ),                   \
                .info = name ## _info,                                  \
                .info_len = sizeof ( name ## _info ),                   \
                .prk = name ## _prk,                                    \
                .prk_len = sizeof ( name ## _prk ),                     \
                .okm = name ## _okm,                                    \
                .okm_len = sizeof ( name ## _okm ),                     \
        }

◆ hkdf_ok

#define hkdf_ok ( test )

Value:

hkdf_okx ( test, __FILE__, __LINE__ )

test

static int test

Definition epic100.c:73

hkdf_okx

void hkdf_okx(struct hkdf_test *test, const char *file, unsigned int line)

Report an HKDF test result.

Definition hkdf_test.c:51

Report an HKDF test result.

Parameters

test HMAC test

Definition at line 100 of file hkdf_test.h.

Referenced by hkdf_test_exec(), wycheproof_hkdf_sha1_exec(), wycheproof_hkdf_sha256_exec(), wycheproof_hkdf_sha384_exec(), and wycheproof_hkdf_sha512_exec().

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ hkdf_okx()

void hkdf_okx	(	struct hkdf_test *	test,
		const char *	file,
		unsigned int	line )

extern

Report an HKDF test result.

Parameters

test	HKDF test
file	Test code file
line	Test code line

Definition at line 51 of file hkdf_test.c.

                                    {
        size_t digestsize = test->digest->digestsize;
        union {
                uint8_t ikm[test->ikm_len];
                uint8_t salt[test->salt_len];
                uint8_t info[test->info_len];
                uint8_t prk[digestsize];
                uint8_t okm[test->okm_len];
        } overlap;
        uint8_t prk[digestsize];
        uint8_t okm[test->okm_len];
        size_t check_len;
 
        /* Sanity checks */
        okx ( ( test->salt != NULL ) || ( test->salt_len == 0 ), file, line );
        okx ( ( test->prk_len == 0 ) || ( test->prk_len == digestsize ),
              file, line );
 
        /* Test extraction */
        hkdf_extract ( test->digest, test->salt, test->salt_len, test->ikm,
                       test->ikm_len, prk );
        if ( test->prk_len )
                okx ( memcmp ( prk, test->prk, digestsize ) == 0, file, line );
 
        /* Test expansion */
        hkdf_expand ( test->digest, prk, test->info, test->info_len,
                      okm, test->okm_len );
        okx ( memcmp ( okm, test->okm, test->okm_len ) == 0, file, line );
 
        /* Test overlap between salt and pseudorandom key */
        if ( test->salt ) {
                memcpy ( overlap.salt, test->salt, test->salt_len );
                hkdf_extract ( test->digest, overlap.salt, test->salt_len,
                               test->ikm, test->ikm_len, overlap.prk );
                okx ( memcmp ( overlap.prk, prk, digestsize ) == 0,
                      file, line );
        }
 
        /* Test overlap between input keying material and pseudorandom key */
        memcpy ( overlap.ikm, test->ikm, test->ikm_len );
        hkdf_extract ( test->digest, test->salt, test->salt_len, overlap.ikm,
                       test->ikm_len, overlap.prk );
        okx ( memcmp ( overlap.prk, prk, digestsize ) == 0, file, line );
 
        /* Calculate length for expansion overlap tests */
        check_len = test->okm_len;
        if ( check_len > digestsize )
                check_len = digestsize;
 
        /* Test overlap between pseudorandom key and output */
        memcpy ( overlap.prk, prk, digestsize );
        hkdf_expand ( test->digest, overlap.prk, test->info, test->info_len,
                      overlap.okm, test->okm_len );
        okx ( memcmp ( overlap.okm, test->okm, check_len ) == 0, file, line );
 
        /* Test overlap between additional information and output */
        memcpy ( overlap.info, test->info, test->info_len );
        hkdf_expand ( test->digest, prk, overlap.info, test->info_len,
                      overlap.okm, test->okm_len );
        okx ( memcmp ( overlap.okm, test->okm, check_len ) == 0, file, line );
}

References digestsize, hkdf_expand(), hkdf_extract(), info, memcmp(), memcpy(), NULL, okx, and test.

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ IKM

◆ SALT

◆ INFO

◆ PRK

◆ PRK_UNSPECIFIED

◆ OKM

◆ HKDF_TEST

◆ hkdf_ok

Function Documentation

◆ FILE_LICENCE()

◆ hkdf_okx()