iPXE
Functions
dhe.c File Reference

Ephemeral Diffie-Hellman key exchange. More...

#include <stdint.h>
#include <stdlib.h>
#include <errno.h>
#include <ipxe/bigint.h>
#include <ipxe/dhe.h>

Go to the source code of this file.

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
 
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. More...
 

Detailed Description

Ephemeral Diffie-Hellman key exchange.

Definition in file dhe.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ 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 
)

Calculate Diffie-Hellman key.

Parameters
modulusPrime modulus
lenLength of prime modulus
generatorGenerator
generator_lenLength of generator
partnerPartner public key
partner_lenLength of partner public key
privatePrivate key
private_lenLength of private key
Return values
publicPublic key (length equal to prime modulus)
sharedShared secret (length equal to prime modulus)
rcReturn status code

Definition at line 53 of file dhe.c.

56  {
57  unsigned int size = bigint_required_size ( len );
58  unsigned int private_size = bigint_required_size ( private_len );
59  bigint_t ( size ) *mod;
60  bigint_t ( private_size ) *exp;
61  size_t tmp_len = bigint_mod_exp_tmp_len ( mod, exp );
62  struct {
63  bigint_t ( size ) modulus;
64  bigint_t ( size ) generator;
65  bigint_t ( size ) partner;
66  bigint_t ( private_size ) private;
67  bigint_t ( size ) result;
68  uint8_t tmp[tmp_len];
69  } __attribute__ (( packed )) *ctx;
70  int rc;
71 
72  DBGC2 ( modulus, "DHE %p modulus:\n", modulus );
73  DBGC2_HDA ( modulus, 0, modulus, len );
74  DBGC2 ( modulus, "DHE %p generator:\n", modulus );
75  DBGC2_HDA ( modulus, 0, generator, generator_len );
76  DBGC2 ( modulus, "DHE %p partner public key:\n", modulus );
77  DBGC2_HDA ( modulus, 0, partner, partner_len );
78  DBGC2 ( modulus, "DHE %p private key:\n", modulus );
79  DBGC2_HDA ( modulus, 0, private, private_len );
80 
81  /* Sanity checks */
82  if ( generator_len > len ) {
83  DBGC ( modulus, "DHE %p overlength generator\n", modulus );
84  rc = -EINVAL;
85  goto err_sanity;
86  }
87  if ( partner_len > len ) {
88  DBGC ( modulus, "DHE %p overlength partner public key\n",
89  modulus );
90  rc = -EINVAL;
91  goto err_sanity;
92  }
93  if ( private_len > len ) {
94  DBGC ( modulus, "DHE %p overlength private key\n", modulus );
95  rc = -EINVAL;
96  goto err_sanity;
97  }
98 
99  /* Allocate context */
100  ctx = malloc ( sizeof ( *ctx ) );
101  if ( ! ctx ) {
102  rc = -ENOMEM;
103  goto err_alloc;
104  }
105 
106  /* Initialise context */
107  bigint_init ( &ctx->modulus, modulus, len );
108  bigint_init ( &ctx->generator, generator, generator_len );
109  bigint_init ( &ctx->partner, partner, partner_len );
110  bigint_init ( &ctx->private, private, private_len );
111 
112  /* Calculate public key */
113  bigint_mod_exp ( &ctx->generator, &ctx->modulus, &ctx->private,
114  &ctx->result, ctx->tmp );
115  bigint_done ( &ctx->result, public, len );
116  DBGC2 ( modulus, "DHE %p public key:\n", modulus );
117  DBGC2_HDA ( modulus, 0, public, len );
118 
119  /* Calculate shared secret */
120  bigint_mod_exp ( &ctx->partner, &ctx->modulus, &ctx->private,
121  &ctx->result, ctx->tmp );
122  bigint_done ( &ctx->result, shared, len );
123  DBGC2 ( modulus, "DHE %p shared secret:\n", modulus );
124  DBGC2_HDA ( modulus, 0, shared, len );
125 
126  /* Success */
127  rc = 0;
128 
129  free ( ctx );
130  err_alloc:
131  err_sanity:
132  return rc;
133 }
#define __attribute__(x)
Definition: compiler.h:10
#define EINVAL
Invalid argument.
Definition: errno.h:428
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define bigint_mod_exp(base, modulus, exponent, result, tmp)
Perform modular exponentiation of big integers.
Definition: bigint.h:314
#define DBGC(...)
Definition: compiler.h:505
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:50
struct golan_eq_context ctx
Definition: CIB_PRM.h:28
unsigned long tmp
Definition: linux_pci.h:63
#define ENOMEM
Not enough space.
Definition: errno.h:534
#define bigint_mod_exp_tmp_len(modulus, exponent)
Calculate temporary working space required for moduluar exponentiation.
Definition: bigint.h:329
#define bigint_done(value, out, len)
Finalise big integer.
Definition: bigint.h:63
#define DBGC2_HDA(...)
Definition: compiler.h:523
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
#define bigint_required_size(len)
Determine number of elements required for a big-integer type.
Definition: bigint.h:30
unsigned char uint8_t
Definition: stdint.h:10
void * malloc(size_t size)
Allocate memory.
Definition: malloc.c:583
uint16_t result
Definition: hyperv.h:33
#define DBGC2(...)
Definition: compiler.h:522
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
uint32_t len
Length.
Definition: ena.h:14
struct eth_slow_lacp_entity_tlv partner
Partner information.
Definition: eth_slow.h:16
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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().