dhe.h File Reference

Ephemeral Diffie-Hellman key exchange. More...

#include <stdint.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
int	dhe_key (const void *modulus, size_t len, const void *generator, size_t generator_len, const void *partner, size_t partner_len, const void *private, size_t private_len, void *public, void *shared)
	Calculate Diffie-Hellman key.

Detailed Description

Ephemeral Diffie-Hellman key exchange.

Definition in file dhe.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

References len, and partner.

dhe_key()

int dhe_key ( const void * modulus, size_t len, const void * generator, size_t generator_len, const void * partner, size_t partner_len, const void * private, size_t private_len, void * public, void * shared )

extern

Calculate Diffie-Hellman key.

Parameters

modulus	Prime modulus
len	Length of prime modulus
generator	Generator
generator_len	Length of generator
partner	Partner public key
partner_len	Length of partner public key
private	Private key
private_len	Length of private key

Return values

public	Public key (length equal to prime modulus)
shared	Shared secret (length equal to prime modulus)
rc	Return status code

Definition at line 54 of file dhe.c.

                             {
        unsigned int size = bigint_required_size ( len );
        unsigned int private_size = bigint_required_size ( private_len );
        bigint_t ( size ) *mod;
        size_t tmp_len = bigint_mod_exp_tmp_len ( mod );
        struct {
                bigint_t ( size ) modulus;
                bigint_t ( size ) generator;
                bigint_t ( size ) partner;
                bigint_t ( private_size ) private;
                bigint_t ( size ) result;
                uint8_t tmp[tmp_len];
        } __attribute__ (( packed )) *ctx;
        int rc;
 
        DBGC2 ( modulus, "DHE %p modulus:\n", modulus );
        DBGC2_HDA ( modulus, 0, modulus, len );
        DBGC2 ( modulus, "DHE %p generator:\n", modulus );
        DBGC2_HDA ( modulus, 0, generator, generator_len );
        DBGC2 ( modulus, "DHE %p partner public key:\n", modulus );
        DBGC2_HDA ( modulus, 0, partner, partner_len );
        DBGC2 ( modulus, "DHE %p private key:\n", modulus );
        DBGC2_HDA ( modulus, 0, private, private_len );
 
        /* Sanity checks */
        if ( generator_len > len ) {
                DBGC ( modulus, "DHE %p overlength generator\n", modulus );
                rc = -EINVAL;
                goto err_sanity;
        }
        if ( partner_len > len ) {
                DBGC ( modulus, "DHE %p overlength partner public key\n",
                       modulus );
                rc = -EINVAL;
                goto err_sanity;
        }
        if ( private_len > len ) {
                DBGC ( modulus, "DHE %p overlength private key\n", modulus );
                rc = -EINVAL;
                goto err_sanity;
        }
 
        /* Allocate context */
        ctx = malloc ( sizeof ( *ctx ) );
        if ( ! ctx ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Initialise context */
        bigint_init ( &ctx->modulus, modulus, len );
        bigint_init ( &ctx->generator, generator, generator_len );
        bigint_init ( &ctx->partner, partner, partner_len );
        bigint_init ( &ctx->private, private, private_len );
 
        /* Calculate public key */
        bigint_mod_exp ( &ctx->generator, &ctx->modulus, &ctx->private,
                         &ctx->result, ctx->tmp );
        bigint_done ( &ctx->result, public, len );
        DBGC2 ( modulus, "DHE %p public key:\n", modulus );
        DBGC2_HDA ( modulus, 0, public, len );
 
        /* Calculate shared secret */
        bigint_mod_exp ( &ctx->partner, &ctx->modulus, &ctx->private,
                         &ctx->result, ctx->tmp );
        bigint_done ( &ctx->result, shared, len );
        DBGC2 ( modulus, "DHE %p shared secret:\n", modulus );
        DBGC2_HDA ( modulus, 0, shared, len );
 
        /* Success */
        rc = 0;
 
        free ( ctx );
 err_alloc:
 err_sanity:
        return rc;
}

References __attribute__, bigint_done, bigint_init, bigint_mod_exp, bigint_mod_exp_tmp_len, bigint_required_size, bigint_t, ctx, DBGC, DBGC2, DBGC2_HDA, EINVAL, ENOMEM, free, len, malloc(), partner, rc, result, size, and tmp.

Referenced by dhe_key_okx(), and tls_send_client_key_exchange_dhe().