Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Diffie-Hellman-Merkle key exchange |
| 3 | * |
Manuel Pégourié-Gonnard | 6fb8187 | 2015-07-27 11:11:48 +0200 | [diff] [blame] | 4 | * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: Apache-2.0 |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 8 | * not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
Paul Bakker | b96f154 | 2010-07-18 20:36:00 +0000 | [diff] [blame] | 18 | * |
Manuel Pégourié-Gonnard | fe44643 | 2015-03-06 13:17:10 +0000 | [diff] [blame] | 19 | * This file is part of mbed TLS (https://tls.mbed.org) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 20 | */ |
| 21 | /* |
Simon Butcher | bdae02c | 2016-01-20 00:44:42 +0000 | [diff] [blame] | 22 | * The following sources were referenced in the design of this implementation |
| 23 | * of the Diffie-Hellman-Merkle algorithm: |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 24 | * |
Simon Butcher | bdae02c | 2016-01-20 00:44:42 +0000 | [diff] [blame] | 25 | * [1] Handbook of Applied Cryptography - 1997, Chapter 12 |
| 26 | * Menezes, van Oorschot and Vanstone |
| 27 | * |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 28 | */ |
| 29 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 30 | #if !defined(MBEDTLS_CONFIG_FILE) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 31 | #include "mbedtls/config.h" |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 32 | #else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 33 | #include MBEDTLS_CONFIG_FILE |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 34 | #endif |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 35 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 36 | #if defined(MBEDTLS_DHM_C) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 37 | |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 38 | #include "mbedtls/dhm.h" |
Andres Amaya Garcia | 1f6301b | 2018-04-17 09:51:09 -0500 | [diff] [blame] | 39 | #include "mbedtls/platform_util.h" |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 40 | #include "mbedtls/error.h" |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 41 | |
Rich Evans | 00ab470 | 2015-02-06 13:43:58 +0000 | [diff] [blame] | 42 | #include <string.h> |
| 43 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 44 | #if defined(MBEDTLS_PEM_PARSE_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 45 | #include "mbedtls/pem.h" |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 46 | #endif |
| 47 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 48 | #if defined(MBEDTLS_ASN1_PARSE_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 49 | #include "mbedtls/asn1.h" |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 50 | #endif |
| 51 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 52 | #if defined(MBEDTLS_PLATFORM_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 53 | #include "mbedtls/platform.h" |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 54 | #else |
| 55 | #include <stdlib.h> |
Manuel Pégourié-Gonnard | 981732b | 2015-02-17 15:46:45 +0000 | [diff] [blame] | 56 | #include <stdio.h> |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 57 | #define mbedtls_printf printf |
Manuel Pégourié-Gonnard | 7551cb9 | 2015-05-26 16:04:06 +0200 | [diff] [blame] | 58 | #define mbedtls_calloc calloc |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 59 | #define mbedtls_free free |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 60 | #endif |
| 61 | |
Reuven Levin | 1f35ca9 | 2017-12-07 10:09:32 +0000 | [diff] [blame] | 62 | #if !defined(MBEDTLS_DHM_ALT) |
Paul Bakker | 3461772 | 2014-06-13 17:20:13 +0200 | [diff] [blame] | 63 | |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 64 | #define DHM_VALIDATE_RET( cond ) \ |
| 65 | MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_DHM_BAD_INPUT_DATA ) |
| 66 | #define DHM_VALIDATE( cond ) \ |
| 67 | MBEDTLS_INTERNAL_VALIDATE( cond ) |
| 68 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 69 | /* |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 70 | * helper to validate the mbedtls_mpi size and import it |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 71 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 72 | static int dhm_read_bignum( mbedtls_mpi *X, |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 73 | unsigned char **p, |
Paul Bakker | ff60ee6 | 2010-03-16 21:09:09 +0000 | [diff] [blame] | 74 | const unsigned char *end ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 75 | { |
| 76 | int ret, n; |
| 77 | |
| 78 | if( end - *p < 2 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 79 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 80 | |
| 81 | n = ( (*p)[0] << 8 ) | (*p)[1]; |
| 82 | (*p) += 2; |
| 83 | |
| 84 | if( (int)( end - *p ) < n ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 85 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 86 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 87 | if( ( ret = mbedtls_mpi_read_binary( X, *p, n ) ) != 0 ) |
| 88 | return( MBEDTLS_ERR_DHM_READ_PARAMS_FAILED + ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 89 | |
| 90 | (*p) += n; |
| 91 | |
| 92 | return( 0 ); |
| 93 | } |
| 94 | |
| 95 | /* |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 96 | * Verify sanity of parameter with regards to P |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 97 | * |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 98 | * Parameter should be: 2 <= public_param <= P - 2 |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 99 | * |
Janos Follath | aa325d7 | 2017-09-20 15:33:24 +0100 | [diff] [blame] | 100 | * This means that we need to return an error if |
Janos Follath | 1ad1c6d | 2017-09-21 09:02:11 +0100 | [diff] [blame] | 101 | * public_param < 2 or public_param > P-2 |
Janos Follath | aa325d7 | 2017-09-20 15:33:24 +0100 | [diff] [blame] | 102 | * |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 103 | * For more information on the attack, see: |
| 104 | * http://www.cl.cam.ac.uk/~rja14/Papers/psandqs.pdf |
| 105 | * http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2005-2643 |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 106 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 107 | static int dhm_check_range( const mbedtls_mpi *param, const mbedtls_mpi *P ) |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 108 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 109 | mbedtls_mpi L, U; |
Janos Follath | aa325d7 | 2017-09-20 15:33:24 +0100 | [diff] [blame] | 110 | int ret = 0; |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 111 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 112 | mbedtls_mpi_init( &L ); mbedtls_mpi_init( &U ); |
Paul Bakker | 3d8fb63 | 2014-04-17 12:42:41 +0200 | [diff] [blame] | 113 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 114 | MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &L, 2 ) ); |
| 115 | MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &U, P, 2 ) ); |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 116 | |
Janos Follath | aa325d7 | 2017-09-20 15:33:24 +0100 | [diff] [blame] | 117 | if( mbedtls_mpi_cmp_mpi( param, &L ) < 0 || |
| 118 | mbedtls_mpi_cmp_mpi( param, &U ) > 0 ) |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 119 | { |
Janos Follath | aa325d7 | 2017-09-20 15:33:24 +0100 | [diff] [blame] | 120 | ret = MBEDTLS_ERR_DHM_BAD_INPUT_DATA; |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 121 | } |
| 122 | |
Paul Bakker | 3d8fb63 | 2014-04-17 12:42:41 +0200 | [diff] [blame] | 123 | cleanup: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 124 | mbedtls_mpi_free( &L ); mbedtls_mpi_free( &U ); |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 125 | return( ret ); |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 126 | } |
| 127 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 128 | void mbedtls_dhm_init( mbedtls_dhm_context *ctx ) |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 129 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 130 | DHM_VALIDATE( ctx != NULL ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 131 | memset( ctx, 0, sizeof( mbedtls_dhm_context ) ); |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 132 | } |
| 133 | |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 134 | /* |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 135 | * Parse the ServerKeyExchange parameters |
| 136 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 137 | int mbedtls_dhm_read_params( mbedtls_dhm_context *ctx, |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 138 | unsigned char **p, |
Paul Bakker | ff60ee6 | 2010-03-16 21:09:09 +0000 | [diff] [blame] | 139 | const unsigned char *end ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 140 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 141 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 142 | DHM_VALIDATE_RET( ctx != NULL ); |
| 143 | DHM_VALIDATE_RET( p != NULL && *p != NULL ); |
| 144 | DHM_VALIDATE_RET( end != NULL ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 145 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 146 | if( ( ret = dhm_read_bignum( &ctx->P, p, end ) ) != 0 || |
| 147 | ( ret = dhm_read_bignum( &ctx->G, p, end ) ) != 0 || |
| 148 | ( ret = dhm_read_bignum( &ctx->GY, p, end ) ) != 0 ) |
| 149 | return( ret ); |
| 150 | |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 151 | if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 ) |
| 152 | return( ret ); |
| 153 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 154 | ctx->len = mbedtls_mpi_size( &ctx->P ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 155 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 156 | return( 0 ); |
| 157 | } |
| 158 | |
| 159 | /* |
| 160 | * Setup and write the ServerKeyExchange parameters |
| 161 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 162 | int mbedtls_dhm_make_params( mbedtls_dhm_context *ctx, int x_size, |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 163 | unsigned char *output, size_t *olen, |
Paul Bakker | a3d195c | 2011-11-27 21:07:34 +0000 | [diff] [blame] | 164 | int (*f_rng)(void *, unsigned char *, size_t), |
| 165 | void *p_rng ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 166 | { |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 167 | int ret, count = 0; |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 168 | size_t n1, n2, n3; |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 169 | unsigned char *p; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 170 | DHM_VALIDATE_RET( ctx != NULL ); |
| 171 | DHM_VALIDATE_RET( output != NULL ); |
| 172 | DHM_VALIDATE_RET( olen != NULL ); |
| 173 | DHM_VALIDATE_RET( f_rng != NULL ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 174 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 175 | if( mbedtls_mpi_cmp_int( &ctx->P, 0 ) == 0 ) |
| 176 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | b5b20f1 | 2012-09-16 15:07:49 +0000 | [diff] [blame] | 177 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 178 | /* |
Paul Bakker | ff7fe67 | 2010-07-18 09:45:05 +0000 | [diff] [blame] | 179 | * Generate X as large as possible ( < P ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 180 | */ |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 181 | do |
| 182 | { |
Ron Eldor | 7269fee | 2017-01-12 14:50:50 +0200 | [diff] [blame] | 183 | MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 184 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 185 | while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 ) |
| 186 | MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) ); |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 187 | |
| 188 | if( count++ > 10 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 189 | return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED ); |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 190 | } |
| 191 | while( dhm_check_range( &ctx->X, &ctx->P ) != 0 ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 192 | |
Paul Bakker | ff7fe67 | 2010-07-18 09:45:05 +0000 | [diff] [blame] | 193 | /* |
| 194 | * Calculate GX = G^X mod P |
| 195 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 196 | MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X, |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 197 | &ctx->P , &ctx->RP ) ); |
| 198 | |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 199 | if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 ) |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 200 | return( ret ); |
| 201 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 202 | /* |
| 203 | * export P, G, GX |
| 204 | */ |
Hanno Becker | de6c164 | 2017-10-02 15:03:15 +0100 | [diff] [blame] | 205 | #define DHM_MPI_EXPORT( X, n ) \ |
Hanno Becker | e71ad12 | 2017-09-28 10:32:25 +0100 | [diff] [blame] | 206 | do { \ |
Hanno Becker | de6c164 | 2017-10-02 15:03:15 +0100 | [diff] [blame] | 207 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( ( X ), \ |
| 208 | p + 2, \ |
| 209 | ( n ) ) ); \ |
| 210 | *p++ = (unsigned char)( ( n ) >> 8 ); \ |
| 211 | *p++ = (unsigned char)( ( n ) ); \ |
| 212 | p += ( n ); \ |
Hanno Becker | e71ad12 | 2017-09-28 10:32:25 +0100 | [diff] [blame] | 213 | } while( 0 ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 214 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 215 | n1 = mbedtls_mpi_size( &ctx->P ); |
| 216 | n2 = mbedtls_mpi_size( &ctx->G ); |
| 217 | n3 = mbedtls_mpi_size( &ctx->GX ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 218 | |
| 219 | p = output; |
| 220 | DHM_MPI_EXPORT( &ctx->P , n1 ); |
| 221 | DHM_MPI_EXPORT( &ctx->G , n2 ); |
| 222 | DHM_MPI_EXPORT( &ctx->GX, n3 ); |
| 223 | |
Hanno Becker | e71ad12 | 2017-09-28 10:32:25 +0100 | [diff] [blame] | 224 | *olen = p - output; |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 225 | |
| 226 | ctx->len = n1; |
| 227 | |
| 228 | cleanup: |
| 229 | |
| 230 | if( ret != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 231 | return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED + ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 232 | |
| 233 | return( 0 ); |
| 234 | } |
| 235 | |
| 236 | /* |
Hanno Becker | 8880e75 | 2017-10-04 13:15:08 +0100 | [diff] [blame] | 237 | * Set prime modulus and generator |
| 238 | */ |
| 239 | int mbedtls_dhm_set_group( mbedtls_dhm_context *ctx, |
| 240 | const mbedtls_mpi *P, |
| 241 | const mbedtls_mpi *G ) |
| 242 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 243 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 244 | DHM_VALIDATE_RET( ctx != NULL ); |
| 245 | DHM_VALIDATE_RET( P != NULL ); |
| 246 | DHM_VALIDATE_RET( G != NULL ); |
Hanno Becker | 8880e75 | 2017-10-04 13:15:08 +0100 | [diff] [blame] | 247 | |
| 248 | if( ( ret = mbedtls_mpi_copy( &ctx->P, P ) ) != 0 || |
| 249 | ( ret = mbedtls_mpi_copy( &ctx->G, G ) ) != 0 ) |
| 250 | { |
| 251 | return( MBEDTLS_ERR_DHM_SET_GROUP_FAILED + ret ); |
| 252 | } |
| 253 | |
| 254 | ctx->len = mbedtls_mpi_size( &ctx->P ); |
| 255 | return( 0 ); |
| 256 | } |
| 257 | |
| 258 | /* |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 259 | * Import the peer's public value G^Y |
| 260 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 261 | int mbedtls_dhm_read_public( mbedtls_dhm_context *ctx, |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 262 | const unsigned char *input, size_t ilen ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 263 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 264 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 265 | DHM_VALIDATE_RET( ctx != NULL ); |
| 266 | DHM_VALIDATE_RET( input != NULL ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 267 | |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 268 | if( ilen < 1 || ilen > ctx->len ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 269 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 270 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 271 | if( ( ret = mbedtls_mpi_read_binary( &ctx->GY, input, ilen ) ) != 0 ) |
| 272 | return( MBEDTLS_ERR_DHM_READ_PUBLIC_FAILED + ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 273 | |
| 274 | return( 0 ); |
| 275 | } |
| 276 | |
| 277 | /* |
| 278 | * Create own private value X and export G^X |
| 279 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 280 | int mbedtls_dhm_make_public( mbedtls_dhm_context *ctx, int x_size, |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 281 | unsigned char *output, size_t olen, |
Paul Bakker | a3d195c | 2011-11-27 21:07:34 +0000 | [diff] [blame] | 282 | int (*f_rng)(void *, unsigned char *, size_t), |
| 283 | void *p_rng ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 284 | { |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 285 | int ret, count = 0; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 286 | DHM_VALIDATE_RET( ctx != NULL ); |
| 287 | DHM_VALIDATE_RET( output != NULL ); |
| 288 | DHM_VALIDATE_RET( f_rng != NULL ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 289 | |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 290 | if( olen < 1 || olen > ctx->len ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 291 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 292 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 293 | if( mbedtls_mpi_cmp_int( &ctx->P, 0 ) == 0 ) |
| 294 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | b5b20f1 | 2012-09-16 15:07:49 +0000 | [diff] [blame] | 295 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 296 | /* |
| 297 | * generate X and calculate GX = G^X mod P |
| 298 | */ |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 299 | do |
| 300 | { |
Ron Eldor | 7269fee | 2017-01-12 14:50:50 +0200 | [diff] [blame] | 301 | MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 302 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 303 | while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 ) |
| 304 | MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) ); |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 305 | |
| 306 | if( count++ > 10 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 307 | return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED ); |
Paul Bakker | aec37cb | 2012-04-26 18:59:59 +0000 | [diff] [blame] | 308 | } |
| 309 | while( dhm_check_range( &ctx->X, &ctx->P ) != 0 ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 310 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 311 | MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X, |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 312 | &ctx->P , &ctx->RP ) ); |
| 313 | |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 314 | if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 ) |
| 315 | return( ret ); |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 316 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 317 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->GX, output, olen ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 318 | |
| 319 | cleanup: |
| 320 | |
| 321 | if( ret != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 322 | return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED + ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 323 | |
| 324 | return( 0 ); |
| 325 | } |
| 326 | |
| 327 | /* |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 328 | * Use the blinding method and optimisation suggested in section 10 of: |
| 329 | * KOCHER, Paul C. Timing attacks on implementations of Diffie-Hellman, RSA, |
Manuel Pégourié-Gonnard | 998930a | 2015-04-03 13:48:06 +0200 | [diff] [blame] | 330 | * DSS, and other systems. In : Advances in Cryptology-CRYPTO'96. Springer |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 331 | * Berlin Heidelberg, 1996. p. 104-113. |
| 332 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 333 | static int dhm_update_blinding( mbedtls_dhm_context *ctx, |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 334 | int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) |
| 335 | { |
| 336 | int ret, count; |
| 337 | |
| 338 | /* |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 339 | * Don't use any blinding the first time a particular X is used, |
| 340 | * but remember it to use blinding next time. |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 341 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 342 | if( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->pX ) != 0 ) |
Manuel Pégourié-Gonnard | ed8a02b | 2013-09-04 16:39:03 +0200 | [diff] [blame] | 343 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 344 | MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &ctx->pX, &ctx->X ) ); |
| 345 | MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->Vi, 1 ) ); |
| 346 | MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->Vf, 1 ) ); |
Manuel Pégourié-Gonnard | ed8a02b | 2013-09-04 16:39:03 +0200 | [diff] [blame] | 347 | |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 348 | return( 0 ); |
| 349 | } |
| 350 | |
| 351 | /* |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 352 | * Ok, we need blinding. Can we re-use existing values? |
| 353 | * If yes, just update them by squaring them. |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 354 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 355 | if( mbedtls_mpi_cmp_int( &ctx->Vi, 1 ) != 0 ) |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 356 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 357 | MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) ); |
| 358 | MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->P ) ); |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 359 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 360 | MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) ); |
| 361 | MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->P ) ); |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 362 | |
| 363 | return( 0 ); |
| 364 | } |
| 365 | |
| 366 | /* |
| 367 | * We need to generate blinding values from scratch |
| 368 | */ |
| 369 | |
| 370 | /* Vi = random( 2, P-1 ) */ |
| 371 | count = 0; |
| 372 | do |
| 373 | { |
Ron Eldor | 7269fee | 2017-01-12 14:50:50 +0200 | [diff] [blame] | 374 | MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &ctx->Vi, mbedtls_mpi_size( &ctx->P ), f_rng, p_rng ) ); |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 375 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 376 | while( mbedtls_mpi_cmp_mpi( &ctx->Vi, &ctx->P ) >= 0 ) |
| 377 | MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->Vi, 1 ) ); |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 378 | |
| 379 | if( count++ > 10 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 380 | return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE ); |
Manuel Pégourié-Gonnard | 15d5de1 | 2013-09-17 11:34:11 +0200 | [diff] [blame] | 381 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 382 | while( mbedtls_mpi_cmp_int( &ctx->Vi, 1 ) <= 0 ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 383 | |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 384 | /* Vf = Vi^-X mod P */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 385 | MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->Vf, &ctx->Vi, &ctx->P ) ); |
| 386 | MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->Vf, &ctx->Vf, &ctx->X, &ctx->P, &ctx->RP ) ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 387 | |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 388 | cleanup: |
| 389 | return( ret ); |
| 390 | } |
| 391 | |
| 392 | /* |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 393 | * Derive and export the shared secret (G^Y)^X mod P |
| 394 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 395 | int mbedtls_dhm_calc_secret( mbedtls_dhm_context *ctx, |
Manuel Pégourié-Gonnard | 3335205 | 2015-06-02 16:17:08 +0100 | [diff] [blame] | 396 | unsigned char *output, size_t output_size, size_t *olen, |
Manuel Pégourié-Gonnard | 2d62764 | 2013-09-04 14:22:07 +0200 | [diff] [blame] | 397 | int (*f_rng)(void *, unsigned char *, size_t), |
| 398 | void *p_rng ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 399 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 400 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 401 | mbedtls_mpi GYb; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 402 | DHM_VALIDATE_RET( ctx != NULL ); |
| 403 | DHM_VALIDATE_RET( output != NULL ); |
| 404 | DHM_VALIDATE_RET( olen != NULL ); |
Manuel Pégourié-Gonnard | 2d62764 | 2013-09-04 14:22:07 +0200 | [diff] [blame] | 405 | |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 406 | if( output_size < ctx->len ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 407 | return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 408 | |
Paul Bakker | 345a6fe | 2011-02-28 21:20:02 +0000 | [diff] [blame] | 409 | if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 ) |
Paul Bakker | c47840e | 2011-02-20 16:37:30 +0000 | [diff] [blame] | 410 | return( ret ); |
| 411 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 412 | mbedtls_mpi_init( &GYb ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 413 | |
| 414 | /* Blind peer's value */ |
Manuel Pégourié-Gonnard | ed8a02b | 2013-09-04 16:39:03 +0200 | [diff] [blame] | 415 | if( f_rng != NULL ) |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 416 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 417 | MBEDTLS_MPI_CHK( dhm_update_blinding( ctx, f_rng, p_rng ) ); |
| 418 | MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &GYb, &ctx->GY, &ctx->Vi ) ); |
| 419 | MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &GYb, &GYb, &ctx->P ) ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 420 | } |
| 421 | else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 422 | MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &GYb, &ctx->GY ) ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 423 | |
| 424 | /* Do modular exponentiation */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 425 | MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->K, &GYb, &ctx->X, |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 426 | &ctx->P, &ctx->RP ) ); |
| 427 | |
| 428 | /* Unblind secret value */ |
Manuel Pégourié-Gonnard | ed8a02b | 2013-09-04 16:39:03 +0200 | [diff] [blame] | 429 | if( f_rng != NULL ) |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 430 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 431 | MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->K, &ctx->K, &ctx->Vf ) ); |
| 432 | MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->K, &ctx->K, &ctx->P ) ); |
Manuel Pégourié-Gonnard | 143b502 | 2013-09-04 16:29:59 +0200 | [diff] [blame] | 433 | } |
| 434 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 435 | *olen = mbedtls_mpi_size( &ctx->K ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 436 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 437 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->K, output, *olen ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 438 | |
| 439 | cleanup: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 440 | mbedtls_mpi_free( &GYb ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 441 | |
| 442 | if( ret != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 443 | return( MBEDTLS_ERR_DHM_CALC_SECRET_FAILED + ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 444 | |
| 445 | return( 0 ); |
| 446 | } |
| 447 | |
| 448 | /* |
| 449 | * Free the components of a DHM key |
| 450 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 451 | void mbedtls_dhm_free( mbedtls_dhm_context *ctx ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 452 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 453 | if( ctx == NULL ) |
| 454 | return; |
| 455 | |
| 456 | mbedtls_mpi_free( &ctx->pX ); |
| 457 | mbedtls_mpi_free( &ctx->Vf ); |
| 458 | mbedtls_mpi_free( &ctx->Vi ); |
| 459 | mbedtls_mpi_free( &ctx->RP ); |
| 460 | mbedtls_mpi_free( &ctx->K ); |
| 461 | mbedtls_mpi_free( &ctx->GY ); |
| 462 | mbedtls_mpi_free( &ctx->GX ); |
| 463 | mbedtls_mpi_free( &ctx->X ); |
| 464 | mbedtls_mpi_free( &ctx->G ); |
| 465 | mbedtls_mpi_free( &ctx->P ); |
Manuel Pégourié-Gonnard | b72b4ed | 2013-09-13 13:55:26 +0200 | [diff] [blame] | 466 | |
Andres Amaya Garcia | 1f6301b | 2018-04-17 09:51:09 -0500 | [diff] [blame] | 467 | mbedtls_platform_zeroize( ctx, sizeof( mbedtls_dhm_context ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 468 | } |
| 469 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 470 | #if defined(MBEDTLS_ASN1_PARSE_C) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 471 | /* |
| 472 | * Parse DHM parameters |
| 473 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 474 | int mbedtls_dhm_parse_dhm( mbedtls_dhm_context *dhm, const unsigned char *dhmin, |
Paul Bakker | b9e4e2c | 2014-05-01 14:18:25 +0200 | [diff] [blame] | 475 | size_t dhminlen ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 476 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 477 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 478 | size_t len; |
| 479 | unsigned char *p, *end; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 480 | #if defined(MBEDTLS_PEM_PARSE_C) |
| 481 | mbedtls_pem_context pem; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 482 | #endif /* MBEDTLS_PEM_PARSE_C */ |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 483 | |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 484 | DHM_VALIDATE_RET( dhm != NULL ); |
| 485 | DHM_VALIDATE_RET( dhmin != NULL ); |
| 486 | |
| 487 | #if defined(MBEDTLS_PEM_PARSE_C) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 488 | mbedtls_pem_init( &pem ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 489 | |
Manuel Pégourié-Gonnard | 43b37cb | 2015-05-12 11:20:10 +0200 | [diff] [blame] | 490 | /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */ |
Manuel Pégourié-Gonnard | 0ece0f9 | 2015-05-12 12:43:54 +0200 | [diff] [blame] | 491 | if( dhminlen == 0 || dhmin[dhminlen - 1] != '\0' ) |
Manuel Pégourié-Gonnard | 43b37cb | 2015-05-12 11:20:10 +0200 | [diff] [blame] | 492 | ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT; |
| 493 | else |
| 494 | ret = mbedtls_pem_read_buffer( &pem, |
| 495 | "-----BEGIN DH PARAMETERS-----", |
| 496 | "-----END DH PARAMETERS-----", |
| 497 | dhmin, NULL, 0, &dhminlen ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 498 | |
| 499 | if( ret == 0 ) |
| 500 | { |
| 501 | /* |
| 502 | * Was PEM encoded |
| 503 | */ |
| 504 | dhminlen = pem.buflen; |
| 505 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 506 | else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 507 | goto exit; |
| 508 | |
| 509 | p = ( ret == 0 ) ? pem.buf : (unsigned char *) dhmin; |
| 510 | #else |
| 511 | p = (unsigned char *) dhmin; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 512 | #endif /* MBEDTLS_PEM_PARSE_C */ |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 513 | end = p + dhminlen; |
| 514 | |
| 515 | /* |
| 516 | * DHParams ::= SEQUENCE { |
Daniel Kahn Gillmor | 2ed8173 | 2015-04-03 13:09:24 -0400 | [diff] [blame] | 517 | * prime INTEGER, -- P |
| 518 | * generator INTEGER, -- g |
| 519 | * privateValueLength INTEGER OPTIONAL |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 520 | * } |
| 521 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 522 | if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, |
| 523 | MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 524 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 525 | ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + ret; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 526 | goto exit; |
| 527 | } |
| 528 | |
| 529 | end = p + len; |
| 530 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 531 | if( ( ret = mbedtls_asn1_get_mpi( &p, end, &dhm->P ) ) != 0 || |
| 532 | ( ret = mbedtls_asn1_get_mpi( &p, end, &dhm->G ) ) != 0 ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 533 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 534 | ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + ret; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 535 | goto exit; |
| 536 | } |
| 537 | |
| 538 | if( p != end ) |
| 539 | { |
Manuel Pégourié-Gonnard | de9b363 | 2015-04-17 20:06:31 +0200 | [diff] [blame] | 540 | /* This might be the optional privateValueLength. |
| 541 | * If so, we can cleanly discard it */ |
| 542 | mbedtls_mpi rec; |
| 543 | mbedtls_mpi_init( &rec ); |
| 544 | ret = mbedtls_asn1_get_mpi( &p, end, &rec ); |
| 545 | mbedtls_mpi_free( &rec ); |
Daniel Kahn Gillmor | 2ed8173 | 2015-04-03 13:09:24 -0400 | [diff] [blame] | 546 | if ( ret != 0 ) |
| 547 | { |
Manuel Pégourié-Gonnard | de9b363 | 2015-04-17 20:06:31 +0200 | [diff] [blame] | 548 | ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + ret; |
Daniel Kahn Gillmor | 2ed8173 | 2015-04-03 13:09:24 -0400 | [diff] [blame] | 549 | goto exit; |
| 550 | } |
| 551 | if ( p != end ) |
| 552 | { |
Manuel Pégourié-Gonnard | de9b363 | 2015-04-17 20:06:31 +0200 | [diff] [blame] | 553 | ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + |
| 554 | MBEDTLS_ERR_ASN1_LENGTH_MISMATCH; |
Daniel Kahn Gillmor | 2ed8173 | 2015-04-03 13:09:24 -0400 | [diff] [blame] | 555 | goto exit; |
| 556 | } |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 557 | } |
| 558 | |
| 559 | ret = 0; |
| 560 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 561 | dhm->len = mbedtls_mpi_size( &dhm->P ); |
Manuel Pégourié-Gonnard | 3fec220 | 2014-03-29 16:42:38 +0100 | [diff] [blame] | 562 | |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 563 | exit: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 564 | #if defined(MBEDTLS_PEM_PARSE_C) |
| 565 | mbedtls_pem_free( &pem ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 566 | #endif |
| 567 | if( ret != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 568 | mbedtls_dhm_free( dhm ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 569 | |
| 570 | return( ret ); |
| 571 | } |
| 572 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 573 | #if defined(MBEDTLS_FS_IO) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 574 | /* |
| 575 | * Load all data from a file into a given buffer. |
Manuel Pégourié-Gonnard | 43b37cb | 2015-05-12 11:20:10 +0200 | [diff] [blame] | 576 | * |
| 577 | * The file is expected to contain either PEM or DER encoded data. |
| 578 | * A terminating null byte is always appended. It is included in the announced |
| 579 | * length only if the data looks like it is PEM encoded. |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 580 | */ |
| 581 | static int load_file( const char *path, unsigned char **buf, size_t *n ) |
| 582 | { |
| 583 | FILE *f; |
| 584 | long size; |
| 585 | |
| 586 | if( ( f = fopen( path, "rb" ) ) == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 587 | return( MBEDTLS_ERR_DHM_FILE_IO_ERROR ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 588 | |
| 589 | fseek( f, 0, SEEK_END ); |
| 590 | if( ( size = ftell( f ) ) == -1 ) |
| 591 | { |
| 592 | fclose( f ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 593 | return( MBEDTLS_ERR_DHM_FILE_IO_ERROR ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 594 | } |
| 595 | fseek( f, 0, SEEK_SET ); |
| 596 | |
| 597 | *n = (size_t) size; |
| 598 | |
| 599 | if( *n + 1 == 0 || |
Manuel Pégourié-Gonnard | 7551cb9 | 2015-05-26 16:04:06 +0200 | [diff] [blame] | 600 | ( *buf = mbedtls_calloc( 1, *n + 1 ) ) == NULL ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 601 | { |
| 602 | fclose( f ); |
Manuel Pégourié-Gonnard | 6a8ca33 | 2015-05-28 09:33:39 +0200 | [diff] [blame] | 603 | return( MBEDTLS_ERR_DHM_ALLOC_FAILED ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 604 | } |
| 605 | |
| 606 | if( fread( *buf, 1, *n, f ) != *n ) |
| 607 | { |
| 608 | fclose( f ); |
Andres Amaya Garcia | bdbca7b | 2017-06-23 16:23:21 +0100 | [diff] [blame] | 609 | |
Andres Amaya Garcia | 1f6301b | 2018-04-17 09:51:09 -0500 | [diff] [blame] | 610 | mbedtls_platform_zeroize( *buf, *n + 1 ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 611 | mbedtls_free( *buf ); |
Andres Amaya Garcia | bdbca7b | 2017-06-23 16:23:21 +0100 | [diff] [blame] | 612 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 613 | return( MBEDTLS_ERR_DHM_FILE_IO_ERROR ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 614 | } |
| 615 | |
| 616 | fclose( f ); |
| 617 | |
| 618 | (*buf)[*n] = '\0'; |
| 619 | |
Manuel Pégourié-Gonnard | 43b37cb | 2015-05-12 11:20:10 +0200 | [diff] [blame] | 620 | if( strstr( (const char *) *buf, "-----BEGIN " ) != NULL ) |
| 621 | ++*n; |
| 622 | |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 623 | return( 0 ); |
| 624 | } |
| 625 | |
| 626 | /* |
| 627 | * Load and parse DHM parameters |
| 628 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 629 | int mbedtls_dhm_parse_dhmfile( mbedtls_dhm_context *dhm, const char *path ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 630 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 631 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 632 | size_t n; |
| 633 | unsigned char *buf; |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 634 | DHM_VALIDATE_RET( dhm != NULL ); |
| 635 | DHM_VALIDATE_RET( path != NULL ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 636 | |
Paul Bakker | 66d5d07 | 2014-06-17 16:39:18 +0200 | [diff] [blame] | 637 | if( ( ret = load_file( path, &buf, &n ) ) != 0 ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 638 | return( ret ); |
| 639 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 640 | ret = mbedtls_dhm_parse_dhm( dhm, buf, n ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 641 | |
Andres Amaya Garcia | 1f6301b | 2018-04-17 09:51:09 -0500 | [diff] [blame] | 642 | mbedtls_platform_zeroize( buf, n ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 643 | mbedtls_free( buf ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 644 | |
| 645 | return( ret ); |
| 646 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 647 | #endif /* MBEDTLS_FS_IO */ |
| 648 | #endif /* MBEDTLS_ASN1_PARSE_C */ |
nirekh01 | 49762fa | 2017-12-25 06:46:48 +0000 | [diff] [blame] | 649 | #endif /* MBEDTLS_DHM_ALT */ |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 650 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 651 | #if defined(MBEDTLS_SELF_TEST) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 652 | |
Hanno Becker | 8b0f9e6 | 2019-05-31 17:28:59 +0100 | [diff] [blame] | 653 | #if defined(MBEDTLS_PEM_PARSE_C) |
Manuel Pégourié-Gonnard | 53585ee | 2015-06-25 08:52:25 +0200 | [diff] [blame] | 654 | static const char mbedtls_test_dhm_params[] = |
| 655 | "-----BEGIN DH PARAMETERS-----\r\n" |
| 656 | "MIGHAoGBAJ419DBEOgmQTzo5qXl5fQcN9TN455wkOL7052HzxxRVMyhYmwQcgJvh\r\n" |
| 657 | "1sa18fyfR9OiVEMYglOpkqVoGLN7qd5aQNNi5W7/C+VBdHTBJcGZJyyP5B3qcz32\r\n" |
| 658 | "9mLJKudlVudV0Qxk5qUJaPZ/xupz0NyoVpviuiBOI1gNi8ovSXWzAgEC\r\n" |
| 659 | "-----END DH PARAMETERS-----\r\n"; |
Hanno Becker | 8b0f9e6 | 2019-05-31 17:28:59 +0100 | [diff] [blame] | 660 | #else /* MBEDTLS_PEM_PARSE_C */ |
| 661 | static const char mbedtls_test_dhm_params[] = { |
| 662 | 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0x9e, 0x35, 0xf4, 0x30, 0x44, |
| 663 | 0x3a, 0x09, 0x90, 0x4f, 0x3a, 0x39, 0xa9, 0x79, 0x79, 0x7d, 0x07, 0x0d, |
| 664 | 0xf5, 0x33, 0x78, 0xe7, 0x9c, 0x24, 0x38, 0xbe, 0xf4, 0xe7, 0x61, 0xf3, |
| 665 | 0xc7, 0x14, 0x55, 0x33, 0x28, 0x58, 0x9b, 0x04, 0x1c, 0x80, 0x9b, 0xe1, |
| 666 | 0xd6, 0xc6, 0xb5, 0xf1, 0xfc, 0x9f, 0x47, 0xd3, 0xa2, 0x54, 0x43, 0x18, |
| 667 | 0x82, 0x53, 0xa9, 0x92, 0xa5, 0x68, 0x18, 0xb3, 0x7b, 0xa9, 0xde, 0x5a, |
| 668 | 0x40, 0xd3, 0x62, 0xe5, 0x6e, 0xff, 0x0b, 0xe5, 0x41, 0x74, 0x74, 0xc1, |
| 669 | 0x25, 0xc1, 0x99, 0x27, 0x2c, 0x8f, 0xe4, 0x1d, 0xea, 0x73, 0x3d, 0xf6, |
| 670 | 0xf6, 0x62, 0xc9, 0x2a, 0xe7, 0x65, 0x56, 0xe7, 0x55, 0xd1, 0x0c, 0x64, |
| 671 | 0xe6, 0xa5, 0x09, 0x68, 0xf6, 0x7f, 0xc6, 0xea, 0x73, 0xd0, 0xdc, 0xa8, |
| 672 | 0x56, 0x9b, 0xe2, 0xba, 0x20, 0x4e, 0x23, 0x58, 0x0d, 0x8b, 0xca, 0x2f, |
| 673 | 0x49, 0x75, 0xb3, 0x02, 0x01, 0x02 }; |
| 674 | #endif /* MBEDTLS_PEM_PARSE_C */ |
Manuel Pégourié-Gonnard | 53585ee | 2015-06-25 08:52:25 +0200 | [diff] [blame] | 675 | |
| 676 | static const size_t mbedtls_test_dhm_params_len = sizeof( mbedtls_test_dhm_params ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 677 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 678 | /* |
| 679 | * Checkup routine |
| 680 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 681 | int mbedtls_dhm_self_test( int verbose ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 682 | { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 683 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 684 | mbedtls_dhm_context dhm; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 685 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 686 | mbedtls_dhm_init( &dhm ); |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 687 | |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 688 | if( verbose != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 689 | mbedtls_printf( " DHM parameter load: " ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 690 | |
Manuel Pégourié-Gonnard | 53585ee | 2015-06-25 08:52:25 +0200 | [diff] [blame] | 691 | if( ( ret = mbedtls_dhm_parse_dhm( &dhm, |
| 692 | (const unsigned char *) mbedtls_test_dhm_params, |
| 693 | mbedtls_test_dhm_params_len ) ) != 0 ) |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 694 | { |
| 695 | if( verbose != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 696 | mbedtls_printf( "failed\n" ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 697 | |
Manuel Pégourié-Gonnard | b196fc2 | 2014-07-09 16:53:29 +0200 | [diff] [blame] | 698 | ret = 1; |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 699 | goto exit; |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 700 | } |
| 701 | |
| 702 | if( verbose != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 703 | mbedtls_printf( "passed\n\n" ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 704 | |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 705 | exit: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 706 | mbedtls_dhm_free( &dhm ); |
Paul Bakker | 40ce79f | 2013-09-15 17:43:54 +0200 | [diff] [blame] | 707 | |
Paul Bakker | 8f870b0 | 2014-06-20 13:32:38 +0200 | [diff] [blame] | 708 | return( ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 709 | } |
| 710 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 711 | #endif /* MBEDTLS_SELF_TEST */ |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 712 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 713 | #endif /* MBEDTLS_DHM_C */ |