mirror of
https://github.com/ipxe/ipxe
synced 2026-01-30 16:40:24 +03:00
18b861024a
Add an implementation of the Ephemeral Diffie-Hellman key exchange algorithm as defined in RFC2631, with test vectors taken from the NIST Cryptographic Toolkit. Signed-off-by: Michael Brown <mcb30@ipxe.org>
134 lines
4.1 KiB
C
134 lines
4.1 KiB
C
/*
|
|
* Copyright (C) 2022 Michael Brown <mbrown@fensystems.co.uk>.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*
|
|
* You can also choose to distribute this program under the terms of
|
|
* the Unmodified Binary Distribution Licence (as given in the file
|
|
* COPYING.UBDL), provided that you have satisfied its requirements.
|
|
*/
|
|
|
|
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
|
|
|
|
/** @file
|
|
*
|
|
* Ephemeral Diffie-Hellman key exchange
|
|
*
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <ipxe/bigint.h>
|
|
#include <ipxe/dhe.h>
|
|
|
|
/**
|
|
* Calculate Diffie-Hellman key
|
|
*
|
|
* @v modulus Prime modulus
|
|
* @v len Length of prime modulus
|
|
* @v generator Generator
|
|
* @v generator_len Length of generator
|
|
* @v partner Partner public key
|
|
* @v partner_len Length of partner public key
|
|
* @v private Private key
|
|
* @v private_len Length of private key
|
|
* @ret public Public key (length equal to prime modulus)
|
|
* @ret shared Shared secret (length equal to prime modulus)
|
|
* @ret rc Return status code
|
|
*/
|
|
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 ) {
|
|
unsigned int size = bigint_required_size ( len );
|
|
unsigned int private_size = bigint_required_size ( private_len );
|
|
bigint_t ( size ) *mod;
|
|
bigint_t ( private_size ) *exp;
|
|
size_t tmp_len = bigint_mod_exp_tmp_len ( mod, exp );
|
|
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;
|
|
}
|