rsa.c File Reference

RSA public-key cryptography. More...

#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <ipxe/asn1.h>
#include <ipxe/crypto.h>
#include <ipxe/bigint.h>
#include <ipxe/random_nz.h>
#include <ipxe/rsa.h>

Go to the source code of this file.

Data Structures
struct	rsa_context
	An RSA context. More...

Macros
#define	EACCES_VERIFY   __einfo_error ( EINFO_EACCES_VERIFY )
#define	EINFO_EACCES_VERIFY   __einfo_uniqify ( EINFO_EACCES, 0x01, "RSA signature incorrect" )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static struct rsa_digestinfo_prefix *	rsa_find_prefix (struct digest_algorithm *digest)
	Identify RSA prefix. More...
static void	rsa_free (struct rsa_context *context)
	Free RSA dynamic storage. More...
static int	rsa_alloc (struct rsa_context *context, size_t modulus_len, size_t exponent_len)
	Allocate RSA dynamic storage. More...
static int	rsa_parse_mod_exp (struct asn1_cursor *modulus, struct asn1_cursor *exponent, const struct asn1_cursor *raw)
	Parse RSA modulus and exponent. More...
static int	rsa_init (struct rsa_context *context, const struct asn1_cursor *key)
	Initialise RSA cipher. More...
static void	rsa_cipher (struct rsa_context *context, const void *in, void *out)
	Perform RSA cipher operation. More...
static int	rsa_encrypt (const struct asn1_cursor *key, const struct asn1_cursor *plaintext, struct asn1_builder *ciphertext)
	Encrypt using RSA. More...
static int	rsa_decrypt (const struct asn1_cursor *key, const struct asn1_cursor *ciphertext, struct asn1_builder *plaintext)
	Decrypt using RSA. More...
static int	rsa_encode_digest (struct rsa_context *context, struct digest_algorithm *digest, const void *value, void *encoded)
	Encode RSA digest. More...
static int	rsa_sign (const struct asn1_cursor *key, struct digest_algorithm *digest, const void *value, struct asn1_builder *signature)
	Sign digest value using RSA. More...
static int	rsa_verify (const struct asn1_cursor *key, struct digest_algorithm *digest, const void *value, const struct asn1_cursor *signature)
	Verify signed digest value using RSA. More...
static int	rsa_match (const struct asn1_cursor *private_key, const struct asn1_cursor *public_key)
	Check for matching RSA public/private key pair. More...
	REQUIRING_SYMBOL (rsa_algorithm)
	REQUIRE_OBJECT (config_crypto)

Variables
struct pubkey_algorithm	rsa_algorithm
	RSA public-key algorithm. More...

Detailed Description

RSA public-key cryptography.

RSA is documented in RFC 3447.

Definition in file rsa.c.

Macro Definition Documentation

EACCES_VERIFY

#define EACCES_VERIFY   __einfo_error ( EINFO_EACCES_VERIFY )

Definition at line 46 of file rsa.c.

EINFO_EACCES_VERIFY

#define EINFO_EACCES_VERIFY   __einfo_uniqify ( EINFO_EACCES, 0x01, "RSA signature incorrect" )

Definition at line 48 of file rsa.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

rsa_find_prefix()

static struct rsa_digestinfo_prefix* rsa_find_prefix ( struct digest_algorithm *  digest )

static

Identify RSA prefix.

Parameters

digest

Digest algorithm

Return values

prefix

RSA prefix, or NULL

Definition at line 80 of file rsa.c.

                                                    {
        struct rsa_digestinfo_prefix *prefix;

        for_each_table_entry ( prefix, RSA_DIGESTINFO_PREFIXES ) {
                if ( prefix->digest == digest )
                        return prefix;
        }
        return NULL;
}

References rsa_digestinfo_prefix::digest, for_each_table_entry, NULL, prefix, and RSA_DIGESTINFO_PREFIXES.

Referenced by rsa_encode_digest().

rsa_free()

static void rsa_free ( struct rsa_context *  context )

inlinestatic

Free RSA dynamic storage.

Parameters

context

RSA context

Definition at line 95 of file rsa.c.

                                                            {

        free ( context->dynamic );
}

References rsa_context::dynamic, and free.

Referenced by rsa_decrypt(), rsa_encrypt(), rsa_init(), rsa_sign(), and rsa_verify().

rsa_alloc()

static int rsa_alloc ( struct rsa_context *  context, size_t  modulus_len, size_t  exponent_len  )

static

Allocate RSA dynamic storage.

Parameters

context	RSA context
modulus_len	Modulus length
exponent_len	Exponent length

Return values

rc	Return status code

Definition at line 108 of file rsa.c.

                                             {
        unsigned int size = bigint_required_size ( modulus_len );
        unsigned int exponent_size = bigint_required_size ( exponent_len );
        bigint_t ( size ) *modulus;
        size_t tmp_len = bigint_mod_exp_tmp_len ( modulus );
        struct {
                bigint_t ( size ) modulus;
                bigint_t ( exponent_size ) exponent;
                bigint_t ( size ) input;
                bigint_t ( size ) output;
                uint8_t tmp[tmp_len];
        } __attribute__ (( packed )) *dynamic;

        /* Allocate dynamic storage */
        dynamic = malloc ( sizeof ( *dynamic ) );
        if ( ! dynamic )
                return -ENOMEM;

        /* Assign dynamic storage */
        context->dynamic = dynamic;
        context->modulus0 = &dynamic->modulus.element[0];
        context->size = size;
        context->max_len = modulus_len;
        context->exponent0 = &dynamic->exponent.element[0];
        context->exponent_size = exponent_size;
        context->input0 = &dynamic->input.element[0];
        context->output0 = &dynamic->output.element[0];
        context->tmp = &dynamic->tmp;

        return 0;
}

References __attribute__, bigint_mod_exp_tmp_len, bigint_required_size, bigint_t(), rsa_context::dynamic, ENOMEM, rsa_context::exponent0, rsa_context::exponent_size, rsa_context::input0, malloc(), rsa_context::max_len, rsa_context::modulus0, rsa_context::output0, size, rsa_context::size, tmp, and rsa_context::tmp.

Referenced by rsa_init().

rsa_parse_mod_exp()

static int rsa_parse_mod_exp ( struct asn1_cursor *  modulus, struct asn1_cursor *  exponent, const struct asn1_cursor *  raw  )

static

Parse RSA modulus and exponent.

Parameters

modulus	Modulus to fill in
exponent	Exponent to fill in
raw	ASN.1 cursor

Return values

rc	Return status code

Definition at line 149 of file rsa.c.

                                                               {
        struct asn1_cursor cursor;
        int is_private;
        int rc;

        /* Enter subjectPublicKeyInfo/privateKeyInfo/RSAPrivateKey */
        memcpy ( &cursor, raw, sizeof ( cursor ) );
        asn1_enter ( &cursor, ASN1_SEQUENCE );

        /* Determine key format */
        if ( asn1_type ( &cursor ) == ASN1_INTEGER ) {

                /* Private key */
                is_private = 1;

                /* Skip version */
                asn1_skip_any ( &cursor );

                /* Enter privateKey, if present */
                if ( asn1_check_algorithm ( &cursor, &rsa_encryption_algorithm,
                                            NULL ) == 0 ) {

                        /* Skip privateKeyAlgorithm */
                        asn1_skip_any ( &cursor );

                        /* Enter privateKey */
                        asn1_enter ( &cursor, ASN1_OCTET_STRING );

                        /* Enter RSAPrivateKey */
                        asn1_enter ( &cursor, ASN1_SEQUENCE );

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

        } else {

                /* Public key */
                is_private = 0;

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

                /* Enter subjectPublicKey */
                asn1_enter_bits ( &cursor, NULL );

                /* Enter RSAPublicKey */
                asn1_enter ( &cursor, ASN1_SEQUENCE );
        }

        /* Extract modulus */
        memcpy ( modulus, &cursor, sizeof ( *modulus ) );
        if ( ( rc = asn1_enter_unsigned ( modulus ) ) != 0 )
                return rc;
        asn1_skip_any ( &cursor );

        /* Skip public exponent, if applicable */
        if ( is_private )
                asn1_skip ( &cursor, ASN1_INTEGER );

        /* Extract publicExponent/privateExponent */
        memcpy ( exponent, &cursor, sizeof ( *exponent ) );
        if ( ( rc = asn1_enter_unsigned ( exponent ) ) != 0 )
                return rc;

        return 0;
}

References asn1_check_algorithm(), asn1_enter(), asn1_enter_bits(), asn1_enter_unsigned(), ASN1_INTEGER, ASN1_OCTET_STRING, ASN1_SEQUENCE, asn1_skip(), asn1_skip_any(), asn1_type(), memcpy(), NULL, raw, and rc.

Referenced by rsa_init(), and rsa_match().

rsa_init()

static int rsa_init ( struct rsa_context *  context, const struct asn1_cursor *  key  )

static

Initialise RSA cipher.

Parameters

context	RSA context
key	Key

Return values

rc	Return status code

Definition at line 226 of file rsa.c.

                                                      {
        struct asn1_cursor modulus;
        struct asn1_cursor exponent;
        int rc;

        /* Initialise context */
        memset ( context, 0, sizeof ( *context ) );

        /* Parse modulus and exponent */
        if ( ( rc = rsa_parse_mod_exp ( &modulus, &exponent, key ) ) != 0 ){
                DBGC ( context, "RSA %p invalid modulus/exponent:\n", context );
                DBGC_HDA ( context, 0, key->data, key->len );
                goto err_parse;
        }

        DBGC ( context, "RSA %p modulus:\n", context );
        DBGC_HDA ( context, 0, modulus.data, modulus.len );
        DBGC ( context, "RSA %p exponent:\n", context );
        DBGC_HDA ( context, 0, exponent.data, exponent.len );

        /* Allocate dynamic storage */
        if ( ( rc = rsa_alloc ( context, modulus.len, exponent.len ) ) != 0 )
                goto err_alloc;

        /* Construct big integers */
        bigint_init ( ( ( bigint_t ( context->size ) * ) context->modulus0 ),
                      modulus.data, modulus.len );
        bigint_init ( ( ( bigint_t ( context->exponent_size ) * )
                        context->exponent0 ), exponent.data, exponent.len );

        return 0;

        rsa_free ( context );
 err_alloc:
 err_parse:
        return rc;
}

References bigint_init, bigint_t(), asn1_cursor::data, DBGC, DBGC_HDA, rsa_context::exponent0, rsa_context::exponent_size, key, asn1_cursor::len, memset(), rsa_context::modulus0, rc, rsa_alloc(), rsa_free(), rsa_parse_mod_exp(), and rsa_context::size.

Referenced by rsa_decrypt(), rsa_encrypt(), rsa_sign(), and rsa_verify().

rsa_cipher()

static void rsa_cipher ( struct rsa_context *  context, const void *  in, void *  out  )

static

Perform RSA cipher operation.

Parameters

context	RSA context
in	Input buffer
out	Output buffer

Definition at line 272 of file rsa.c.

                                                     {
        bigint_t ( context->size ) *input = ( ( void * ) context->input0 );
        bigint_t ( context->size ) *output = ( ( void * ) context->output0 );
        bigint_t ( context->size ) *modulus = ( ( void * ) context->modulus0 );
        bigint_t ( context->exponent_size ) *exponent =
                ( ( void * ) context->exponent0 );

        /* Initialise big integer */
        bigint_init ( input, in, context->max_len );

        /* Perform modular exponentiation */
        bigint_mod_exp ( input, modulus, exponent, output, context->tmp );

        /* Copy out result */
        bigint_done ( output, out, context->max_len );
}

References bigint_done, bigint_init, bigint_mod_exp, bigint_t(), rsa_context::exponent0, rsa_context::exponent_size, in, rsa_context::input0, rsa_context::max_len, rsa_context::modulus0, out, rsa_context::output0, rsa_context::size, and rsa_context::tmp.

Referenced by rsa_decrypt(), rsa_encrypt(), rsa_sign(), and rsa_verify().

rsa_encrypt()

static int rsa_encrypt ( const struct asn1_cursor *  key, const struct asn1_cursor *  plaintext, struct asn1_builder *  ciphertext  )

static

Encrypt using RSA.

Parameters

key	Key
plaintext	Plaintext
ciphertext	Ciphertext

Return values

ciphertext_len

Length of ciphertext, or negative error

Definition at line 298 of file rsa.c.

                                                           {
        struct rsa_context context;
        void *temp;
        uint8_t *encoded;
        size_t max_len;
        size_t random_nz_len;
        int rc;

        DBGC ( &context, "RSA %p encrypting:\n", &context );
        DBGC_HDA ( &context, 0, plaintext->data, plaintext->len );

        /* Initialise context */
        if ( ( rc = rsa_init ( &context, key ) ) != 0 )
                goto err_init;

        /* Calculate lengths */
        max_len = ( context.max_len - 11 );
        random_nz_len = ( max_len - plaintext->len + 8 );

        /* Sanity check */
        if ( plaintext->len > max_len ) {
                DBGC ( &context, "RSA %p plaintext too long (%zd bytes, max "
                       "%zd)\n", &context, plaintext->len, max_len );
                rc = -ERANGE;
                goto err_sanity;
        }

        /* Construct encoded message (using the big integer output
         * buffer as temporary storage)
         */
        temp = context.output0;
        encoded = temp;
        encoded[0] = 0x00;
        encoded[1] = 0x02;
        if ( ( rc = get_random_nz ( &encoded[2], random_nz_len ) ) != 0 ) {
                DBGC ( &context, "RSA %p could not generate random data: %s\n",
                       &context, strerror ( rc ) );
                goto err_random;
        }
        encoded[ 2 + random_nz_len ] = 0x00;
        memcpy ( &encoded[ context.max_len - plaintext->len ],
                 plaintext->data, plaintext->len );

        /* Create space for ciphertext */
        if ( ( rc = asn1_grow ( ciphertext, context.max_len ) ) != 0 )
                goto err_grow;

        /* Encipher the encoded message */
        rsa_cipher ( &context, encoded, ciphertext->data );
        DBGC ( &context, "RSA %p encrypted:\n", &context );
        DBGC_HDA ( &context, 0, ciphertext->data, context.max_len );

        /* Free context */
        rsa_free ( &context );

        return 0;

 err_grow:
 err_random:
 err_sanity:
        rsa_free ( &context );
 err_init:
        return rc;
}

References asn1_grow(), asn1_cursor::data, asn1_builder::data, DBGC, DBGC_HDA, ERANGE, get_random_nz(), key, asn1_cursor::len, rsa_context::max_len, memcpy(), rsa_context::output0, rc, rsa_cipher(), rsa_free(), rsa_init(), and strerror().

rsa_decrypt()

static int rsa_decrypt ( const struct asn1_cursor *  key, const struct asn1_cursor *  ciphertext, struct asn1_builder *  plaintext  )

static

Decrypt using RSA.

Parameters

key	Key
ciphertext	Ciphertext
plaintext	Plaintext

Return values

rc	Return status code

Definition at line 373 of file rsa.c.

                                                          {
        struct rsa_context context;
        void *temp;
        uint8_t *encoded;
        uint8_t *end;
        uint8_t *zero;
        uint8_t *start;
        size_t len;
        int rc;

        DBGC ( &context, "RSA %p decrypting:\n", &context );
        DBGC_HDA ( &context, 0, ciphertext->data, ciphertext->len );

        /* Initialise context */
        if ( ( rc = rsa_init ( &context, key ) ) != 0 )
                goto err_init;

        /* Sanity check */
        if ( ciphertext->len != context.max_len ) {
                DBGC ( &context, "RSA %p ciphertext incorrect length (%zd "
                       "bytes, should be %zd)\n",
                       &context, ciphertext->len, context.max_len );
                rc = -ERANGE;
                goto err_sanity;
        }

        /* Decipher the message (using the big integer input buffer as
         * temporary storage)
         */
        temp = context.input0;
        encoded = temp;
        rsa_cipher ( &context, ciphertext->data, encoded );

        /* Parse the message */
        end = ( encoded + context.max_len );
        if ( ( encoded[0] != 0x00 ) || ( encoded[1] != 0x02 ) ) {
                rc = -EINVAL;
                goto err_invalid;
        }
        zero = memchr ( &encoded[2], 0, ( end - &encoded[2] ) );
        if ( ! zero ) {
                DBGC ( &context, "RSA %p invalid decrypted message:\n",
                       &context );
                DBGC_HDA ( &context, 0, encoded, context.max_len );
                rc = -EINVAL;
                goto err_invalid;
        }
        start = ( zero + 1 );
        len = ( end - start );

        /* Create space for plaintext */
        if ( ( rc = asn1_grow ( plaintext, len ) ) != 0 )
                goto err_grow;

        /* Copy out message */
        memcpy ( plaintext->data, start, len );
        DBGC ( &context, "RSA %p decrypted:\n", &context );
        DBGC_HDA ( &context, 0, plaintext->data, len );

        /* Free context */
        rsa_free ( &context );

        return 0;

 err_grow:
 err_invalid:
 err_sanity:
        rsa_free ( &context );
 err_init:
        return rc;
}

References asn1_grow(), asn1_cursor::data, asn1_builder::data, DBGC, DBGC_HDA, EINVAL, end, ERANGE, rsa_context::input0, key, asn1_cursor::len, len, rsa_context::max_len, memchr(), memcpy(), rc, rsa_cipher(), rsa_free(), rsa_init(), and start.

rsa_encode_digest()

static int rsa_encode_digest ( struct rsa_context *  context, struct digest_algorithm *  digest, const void *  value, void *  encoded  )

static

Encode RSA digest.

Parameters

context	RSA context
digest	Digest algorithm
value	Digest value
encoded	Encoded digest

Return values

rc	Return status code

Definition at line 456 of file rsa.c.

                                                                  {
        struct rsa_digestinfo_prefix *prefix;
        size_t digest_len = digest->digestsize;
        uint8_t *temp = encoded;
        size_t digestinfo_len;
        size_t max_len;
        size_t pad_len;

        /* Identify prefix */
        prefix = rsa_find_prefix ( digest );
        if ( ! prefix ) {
                DBGC ( context, "RSA %p has no prefix for %s\n",
                       context, digest->name );
                return -ENOTSUP;
        }
        digestinfo_len = ( prefix->len + digest_len );

        /* Sanity check */
        max_len = ( context->max_len - 11 );
        if ( digestinfo_len > max_len ) {
                DBGC ( context, "RSA %p %s digestInfo too long (%zd bytes, "
                       "max %zd)\n", context, digest->name, digestinfo_len,
                       max_len );
                return -ERANGE;
        }
        DBGC ( context, "RSA %p encoding %s digest:\n",
               context, digest->name );
        DBGC_HDA ( context, 0, value, digest_len );

        /* Construct encoded message */
        *(temp++) = 0x00;
        *(temp++) = 0x01;
        pad_len = ( max_len - digestinfo_len + 8 );
        memset ( temp, 0xff, pad_len );
        temp += pad_len;
        *(temp++) = 0x00;
        memcpy ( temp, prefix->data, prefix->len );
        temp += prefix->len;
        memcpy ( temp, value, digest_len );
        temp += digest_len;
        assert ( temp == ( encoded + context->max_len ) );
        DBGC ( context, "RSA %p encoded %s digest:\n", context, digest->name );
        DBGC_HDA ( context, 0, encoded, context->max_len );

        return 0;
}

References assert(), DBGC, DBGC_HDA, rsa_digestinfo_prefix::digest, digest_algorithm::digestsize, ENOTSUP, ERANGE, rsa_context::max_len, memcpy(), memset(), digest_algorithm::name, pad_len, prefix, rsa_find_prefix(), and value.

Referenced by rsa_sign(), and rsa_verify().

rsa_sign()

static int rsa_sign ( const struct asn1_cursor *  key, struct digest_algorithm *  digest, const void *  value, struct asn1_builder *  signature  )

static

Sign digest value using RSA.

Parameters

key	Key
digest	Digest algorithm
value	Digest value
signature	Signature

Return values

rc	Return status code

Definition at line 514 of file rsa.c.

                                                       {
        struct rsa_context context;
        int rc;

        DBGC ( &context, "RSA %p signing %s digest:\n",
               &context, digest->name );
        DBGC_HDA ( &context, 0, value, digest->digestsize );

        /* Initialise context */
        if ( ( rc = rsa_init ( &context, key ) ) != 0 )
                goto err_init;

        /* Create space for encoded digest and signature */
        if ( ( rc = asn1_grow ( signature, context.max_len ) ) != 0 )
                goto err_grow;

        /* Encode digest */
        if ( ( rc = rsa_encode_digest ( &context, digest, value,
                                        signature->data ) ) != 0 )
                goto err_encode;

        /* Encipher the encoded digest */
        rsa_cipher ( &context, signature->data, signature->data );
        DBGC ( &context, "RSA %p signed %s digest:\n", &context, digest->name );
        DBGC_HDA ( &context, 0, signature->data, signature->len );

        /* Free context */
        rsa_free ( &context );

        return 0;

 err_encode:
 err_grow:
        rsa_free ( &context );
 err_init:
        return rc;
}

References asn1_grow(), DBGC, DBGC_HDA, digest_algorithm::digestsize, key, rsa_context::max_len, digest_algorithm::name, rc, rsa_cipher(), rsa_encode_digest(), rsa_free(), rsa_init(), signature, and value.

rsa_verify()

static int rsa_verify ( const struct asn1_cursor *  key, struct digest_algorithm *  digest, const void *  value, const struct asn1_cursor *  signature  )

static

Verify signed digest value using RSA.

Parameters

key	Key
digest	Digest algorithm
value	Digest value
signature	Signature

Return values

rc	Return status code

Definition at line 563 of file rsa.c.

                                                              {
        struct rsa_context context;
        void *temp;
        void *expected;
        void *actual;
        int rc;

        DBGC ( &context, "RSA %p verifying %s digest:\n",
               &context, digest->name );
        DBGC_HDA ( &context, 0, value, digest->digestsize );
        DBGC_HDA ( &context, 0, signature->data, signature->len );

        /* Initialise context */
        if ( ( rc = rsa_init ( &context, key ) ) != 0 )
                goto err_init;

        /* Sanity check */
        if ( signature->len != context.max_len ) {
                DBGC ( &context, "RSA %p signature incorrect length (%zd "
                       "bytes, should be %zd)\n",
                       &context, signature->len, context.max_len );
                rc = -ERANGE;
                goto err_sanity;
        }

        /* Decipher the signature (using the big integer input buffer
         * as temporary storage)
         */
        temp = context.input0;
        expected = temp;
        rsa_cipher ( &context, signature->data, expected );
        DBGC ( &context, "RSA %p deciphered signature:\n", &context );
        DBGC_HDA ( &context, 0, expected, context.max_len );

        /* Encode digest (using the big integer output buffer as
         * temporary storage)
         */
        temp = context.output0;
        actual = temp;
        if ( ( rc = rsa_encode_digest ( &context, digest, value,
                                        actual ) ) != 0 )
                goto err_encode;

        /* Verify the signature */
        if ( memcmp ( actual, expected, context.max_len ) != 0 ) {
                DBGC ( &context, "RSA %p signature verification failed\n",
                       &context );
                rc = -EACCES_VERIFY;
                goto err_verify;
        }

        /* Free context */
        rsa_free ( &context );

        DBGC ( &context, "RSA %p signature verified successfully\n", &context );
        return 0;

 err_verify:
 err_encode:
 err_sanity:
        rsa_free ( &context );
 err_init:
        return rc;
}

References DBGC, DBGC_HDA, digest_algorithm::digestsize, EACCES_VERIFY, ERANGE, rsa_context::input0, key, rsa_context::max_len, memcmp(), digest_algorithm::name, rsa_context::output0, rc, rsa_cipher(), rsa_encode_digest(), rsa_free(), rsa_init(), signature, and value.

rsa_match()

static int rsa_match ( const struct asn1_cursor *  private_key, const struct asn1_cursor *  public_key  )

static

Check for matching RSA public/private key pair.

Parameters

private_key	Private key
public_key	Public key

Return values

rc	Return status code

Definition at line 637 of file rsa.c.

                                                              {
        struct asn1_cursor private_modulus;
        struct asn1_cursor private_exponent;
        struct asn1_cursor public_modulus;
        struct asn1_cursor public_exponent;
        int rc;

        /* Parse moduli and exponents */
        if ( ( rc = rsa_parse_mod_exp ( &private_modulus, &private_exponent,
                                        private_key ) ) != 0 )
                return rc;
        if ( ( rc = rsa_parse_mod_exp ( &public_modulus, &public_exponent,
                                        public_key ) ) != 0 )
                return rc;

        /* Compare moduli */
        if ( asn1_compare ( &private_modulus, &public_modulus ) != 0 )
                return -ENOTTY;

        return 0;
}

References asn1_compare(), ENOTTY, rc, and rsa_parse_mod_exp().

REQUIRING_SYMBOL()

REQUIRING_SYMBOL

(

rsa_algorithm

)

REQUIRE_OBJECT()

REQUIRE_OBJECT

(

config_crypto

)

Variable Documentation

rsa_algorithm

struct pubkey_algorithm rsa_algorithm

Initial value:

= {
        .name           = "rsa",
        .encrypt        = rsa_encrypt,
        .decrypt        = rsa_decrypt,
        .sign           = rsa_sign,
        .verify         = rsa_verify,
        .match          = rsa_match,
}

RSA public-key algorithm.

Definition at line 661 of file rsa.c.

Referenced by icert_cert().