pubkey_test.c File Reference

Public key self-tests. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ipxe/crypto.h>
#include <ipxe/test.h>
#include "pubkey_test.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
void	pubkey_okx (struct pubkey_test *test, const char *file, unsigned int line)
	Report public key encryption and decryption test result. More...
void	pubkey_sign_okx (struct pubkey_sign_test *test, const char *file, unsigned int line)
	Report public key signature test result. More...

Detailed Description

Public key self-tests.

Definition in file pubkey_test.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

pubkey_okx()

void pubkey_okx	(	struct pubkey_test *	test,
		const char *	file,
		unsigned int	line
	)

Report public key encryption and decryption test result.

Parameters

test	Public key encryption and decryption test
file	Test code file
line	Test code line

Definition at line 50 of file pubkey_test.c.

                                      {
        struct pubkey_algorithm *pubkey = test->pubkey;
        size_t max_len = pubkey_max_len ( pubkey, &test->private );
        uint8_t encrypted[max_len];
        uint8_t decrypted[max_len];
        int encrypted_len;
        int decrypted_len;

        /* Test decrypting with private key to obtain known plaintext */
        decrypted_len = pubkey_decrypt ( pubkey, &test->private,
                                         test->ciphertext, test->ciphertext_len,
                                         decrypted );
        okx ( decrypted_len == ( ( int ) test->plaintext_len ), file, line );
        okx ( memcmp ( decrypted, test->plaintext, test->plaintext_len ) == 0,
              file, line );

        /* Test encrypting with private key and decrypting with public key */
        encrypted_len = pubkey_encrypt ( pubkey, &test->private,
                                         test->plaintext, test->plaintext_len,
                                         encrypted );
        okx ( encrypted_len >= 0, file, line );
        decrypted_len = pubkey_decrypt ( pubkey, &test->public, encrypted,
                                         encrypted_len, decrypted );
        okx ( decrypted_len == ( ( int ) test->plaintext_len ), file, line );
        okx ( memcmp ( decrypted, test->plaintext, test->plaintext_len ) == 0,
              file, line );

        /* Test encrypting with public key and decrypting with private key */
        encrypted_len = pubkey_encrypt ( pubkey, &test->public,
                                         test->plaintext, test->plaintext_len,
                                         encrypted );
        okx ( encrypted_len >= 0, file, line );
        decrypted_len = pubkey_decrypt ( pubkey, &test->private, encrypted,
                                         encrypted_len, decrypted );
        okx ( decrypted_len == ( ( int ) test->plaintext_len ), file, line );
        okx ( memcmp ( decrypted, test->plaintext, test->plaintext_len ) == 0,
              file, line );
}

References pubkey_algorithm::max_len, memcmp(), okx, pubkey_decrypt(), pubkey_encrypt(), pubkey_max_len(), and test.

pubkey_sign_okx()

void pubkey_sign_okx	(	struct pubkey_sign_test *	test,
		const char *	file,
		unsigned int	line
	)

Report public key signature test result.

Parameters

test	Public key signature test
file	Test code file
line	Test code line

Definition at line 97 of file pubkey_test.c.

                                           {
        struct pubkey_algorithm *pubkey = test->pubkey;
        struct digest_algorithm *digest = test->digest;
        size_t max_len = pubkey_max_len ( pubkey, &test->private );
        uint8_t bad[test->signature_len];
        uint8_t digestctx[digest->ctxsize ];
        uint8_t digestout[digest->digestsize];
        uint8_t signature[max_len];
        int signature_len;

        /* Construct digest over plaintext */
        digest_init ( digest, digestctx );
        digest_update ( digest, digestctx, test->plaintext,
                        test->plaintext_len );
        digest_final ( digest, digestctx, digestout );

        /* Test signing using private key */
        signature_len = pubkey_sign ( pubkey, &test->private, digest,
                                      digestout, signature );
        okx ( signature_len == ( ( int ) test->signature_len ), file, line );
        okx ( memcmp ( signature, test->signature, test->signature_len ) == 0,
              file, line );

        /* Test verification using public key */
        okx ( pubkey_verify ( pubkey, &test->public, digest, digestout,
                              test->signature, test->signature_len ) == 0,
              file, line );

        /* Test verification failure of modified signature */
        memcpy ( bad, test->signature, test->signature_len );
        bad[ test->signature_len / 2 ] ^= 0x40;
        okx ( pubkey_verify ( pubkey, &test->public, digest, digestout,
                              bad, sizeof ( bad ) ) != 0, file, line );
}

References digest_algorithm::ctxsize, digest_final(), digest_init(), digest_update(), digest_algorithm::digestsize, memcmp(), memcpy(), okx, pubkey_max_len(), pubkey_sign(), pubkey_verify(), signature, and test.