Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Key reading application |
| 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 | ed56b22 | 2011-07-13 11:26:43 +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 | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 20 | */ |
| 21 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 22 | #if !defined(MBEDTLS_CONFIG_FILE) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 23 | #include "mbedtls/config.h" |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 24 | #else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 25 | #include MBEDTLS_CONFIG_FILE |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 26 | #endif |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 27 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 28 | #if defined(MBEDTLS_PLATFORM_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 29 | #include "mbedtls/platform.h" |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 30 | #else |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 31 | #include <stdio.h> |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 32 | #include <stdlib.h> |
| 33 | #define mbedtls_printf printf |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame^] | 34 | #define mbedtls_exit exit |
Andres Amaya Garcia | 2b0599b | 2018-04-30 22:42:33 +0100 | [diff] [blame] | 35 | #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 36 | #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE |
| 37 | #endif /* MBEDTLS_PLATFORM_C */ |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 38 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 39 | #if defined(MBEDTLS_BIGNUM_C) && \ |
| 40 | defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_FS_IO) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 41 | #include "mbedtls/error.h" |
| 42 | #include "mbedtls/rsa.h" |
| 43 | #include "mbedtls/x509.h" |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 44 | |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 45 | #include <string.h> |
| 46 | #endif |
| 47 | |
| 48 | #define MODE_NONE 0 |
| 49 | #define MODE_PRIVATE 1 |
| 50 | #define MODE_PUBLIC 2 |
| 51 | |
| 52 | #define DFL_MODE MODE_NONE |
| 53 | #define DFL_FILENAME "keyfile.key" |
| 54 | #define DFL_PASSWORD "" |
| 55 | #define DFL_PASSWORD_FILE "" |
| 56 | #define DFL_DEBUG_LEVEL 0 |
Manuel Pégourié-Gonnard | 6c5abfa | 2015-02-13 14:12:07 +0000 | [diff] [blame] | 57 | |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 58 | #define USAGE \ |
| 59 | "\n usage: key_app param=<>...\n" \ |
| 60 | "\n acceptable parameters:\n" \ |
| 61 | " mode=private|public default: none\n" \ |
| 62 | " filename=%%s default: keyfile.key\n" \ |
| 63 | " password=%%s default: \"\"\n" \ |
| 64 | " password_file=%%s default: \"\"\n" \ |
| 65 | "\n" |
| 66 | |
| 67 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 68 | #if !defined(MBEDTLS_BIGNUM_C) || \ |
| 69 | !defined(MBEDTLS_PK_PARSE_C) || !defined(MBEDTLS_FS_IO) |
Rich Evans | 85b05ec | 2015-02-12 11:37:29 +0000 | [diff] [blame] | 70 | int main( void ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 71 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 72 | mbedtls_printf("MBEDTLS_BIGNUM_C and/or " |
| 73 | "MBEDTLS_PK_PARSE_C and/or MBEDTLS_FS_IO not defined.\n"); |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame^] | 74 | mbedtls_exit( 0 ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 75 | } |
| 76 | #else |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 77 | /* |
| 78 | * global options |
| 79 | */ |
| 80 | struct options |
| 81 | { |
| 82 | int mode; /* the mode to run the application in */ |
Paul Bakker | ef3f8c7 | 2013-06-24 13:01:08 +0200 | [diff] [blame] | 83 | const char *filename; /* filename of the key file */ |
| 84 | const char *password; /* password for the private key */ |
| 85 | const char *password_file; /* password_file for the private key */ |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 86 | } opt; |
| 87 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 88 | int main( int argc, char *argv[] ) |
| 89 | { |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 90 | int ret = 1; |
| 91 | int exit_code = MBEDTLS_EXIT_FAILURE; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 92 | char buf[1024]; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 93 | int i; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 94 | char *p, *q; |
| 95 | |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 96 | mbedtls_pk_context pk; |
| 97 | mbedtls_mpi N, P, Q, D, E, DP, DQ, QP; |
| 98 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 99 | /* |
| 100 | * Set to sane values |
| 101 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 102 | mbedtls_pk_init( &pk ); |
Paul Bakker | 2e24ca7 | 2013-09-18 15:21:27 +0200 | [diff] [blame] | 103 | memset( buf, 0, sizeof(buf) ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 104 | |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 105 | mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q ); |
| 106 | mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &DP ); |
| 107 | mbedtls_mpi_init( &DQ ); mbedtls_mpi_init( &QP ); |
| 108 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 109 | if( argc == 0 ) |
| 110 | { |
| 111 | usage: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 112 | mbedtls_printf( USAGE ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 113 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | opt.mode = DFL_MODE; |
| 117 | opt.filename = DFL_FILENAME; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 118 | opt.password = DFL_PASSWORD; |
| 119 | opt.password_file = DFL_PASSWORD_FILE; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 120 | |
| 121 | for( i = 1; i < argc; i++ ) |
| 122 | { |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 123 | p = argv[i]; |
| 124 | if( ( q = strchr( p, '=' ) ) == NULL ) |
| 125 | goto usage; |
| 126 | *q++ = '\0'; |
| 127 | |
| 128 | if( strcmp( p, "mode" ) == 0 ) |
| 129 | { |
| 130 | if( strcmp( q, "private" ) == 0 ) |
| 131 | opt.mode = MODE_PRIVATE; |
| 132 | else if( strcmp( q, "public" ) == 0 ) |
| 133 | opt.mode = MODE_PUBLIC; |
| 134 | else |
| 135 | goto usage; |
| 136 | } |
| 137 | else if( strcmp( p, "filename" ) == 0 ) |
| 138 | opt.filename = q; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 139 | else if( strcmp( p, "password" ) == 0 ) |
| 140 | opt.password = q; |
| 141 | else if( strcmp( p, "password_file" ) == 0 ) |
| 142 | opt.password_file = q; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 143 | else |
| 144 | goto usage; |
| 145 | } |
| 146 | |
| 147 | if( opt.mode == MODE_PRIVATE ) |
| 148 | { |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 149 | if( strlen( opt.password ) && strlen( opt.password_file ) ) |
| 150 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 151 | mbedtls_printf( "Error: cannot have both password and password_file\n" ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 152 | goto usage; |
| 153 | } |
| 154 | |
| 155 | if( strlen( opt.password_file ) ) |
| 156 | { |
| 157 | FILE *f; |
| 158 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 159 | mbedtls_printf( "\n . Loading the password file ..." ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 160 | if( ( f = fopen( opt.password_file, "rb" ) ) == NULL ) |
| 161 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 162 | mbedtls_printf( " failed\n ! fopen returned NULL\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 163 | goto cleanup; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 164 | } |
Paul Bakker | 8a0c0a9 | 2014-04-17 16:08:20 +0200 | [diff] [blame] | 165 | if( fgets( buf, sizeof(buf), f ) == NULL ) |
| 166 | { |
| 167 | fclose( f ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 168 | mbedtls_printf( "Error: fgets() failed to retrieve password\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 169 | goto cleanup; |
Paul Bakker | 8a0c0a9 | 2014-04-17 16:08:20 +0200 | [diff] [blame] | 170 | } |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 171 | fclose( f ); |
| 172 | |
Paul Bakker | 840ab20 | 2013-11-30 15:14:38 +0100 | [diff] [blame] | 173 | i = (int) strlen( buf ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 174 | if( buf[i - 1] == '\n' ) buf[i - 1] = '\0'; |
| 175 | if( buf[i - 2] == '\r' ) buf[i - 2] = '\0'; |
| 176 | opt.password = buf; |
| 177 | } |
| 178 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 179 | /* |
| 180 | * 1.1. Load the key |
| 181 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 182 | mbedtls_printf( "\n . Loading the private key ..." ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 183 | fflush( stdout ); |
| 184 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 185 | ret = mbedtls_pk_parse_keyfile( &pk, opt.filename, opt.password ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 186 | |
| 187 | if( ret != 0 ) |
| 188 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 189 | mbedtls_printf( " failed\n ! mbedtls_pk_parse_keyfile returned -0x%04x\n", -ret ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 190 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 193 | mbedtls_printf( " ok\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 194 | |
| 195 | /* |
| 196 | * 1.2 Print the key |
| 197 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 198 | mbedtls_printf( " . Key information ...\n" ); |
| 199 | #if defined(MBEDTLS_RSA_C) |
| 200 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_RSA ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 201 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 202 | mbedtls_rsa_context *rsa = mbedtls_pk_rsa( pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 203 | |
| 204 | if( ( ret = mbedtls_rsa_export ( rsa, &N, &P, &Q, &D, &E ) ) != 0 || |
| 205 | ( ret = mbedtls_rsa_export_crt( rsa, &DP, &DQ, &QP ) ) != 0 ) |
| 206 | { |
| 207 | mbedtls_printf( " failed\n ! could not export RSA parameters\n\n" ); |
Ron Eldor | 0d63e62 | 2018-06-27 08:49:00 +0300 | [diff] [blame] | 208 | goto cleanup; |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 209 | } |
| 210 | |
Ron Eldor | 5146ef3 | 2018-06-27 11:51:46 +0300 | [diff] [blame] | 211 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "N: ", &N, 16, NULL ) ); |
| 212 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "E: ", &E, 16, NULL ) ); |
| 213 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "D: ", &D, 16, NULL ) ); |
| 214 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "P: ", &P, 16, NULL ) ); |
| 215 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q: ", &Q, 16, NULL ) ); |
| 216 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "DP: ", &DP, 16, NULL ) ); |
| 217 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "DQ: ", &DQ, 16, NULL ) ); |
| 218 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "QP: ", &QP, 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 219 | } |
| 220 | else |
| 221 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 222 | #if defined(MBEDTLS_ECP_C) |
| 223 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_ECKEY ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 224 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 225 | mbedtls_ecp_keypair *ecp = mbedtls_pk_ec( pk ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 226 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ) ); |
| 227 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ) ); |
| 228 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ) ); |
| 229 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "D : ", &ecp->d , 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 230 | } |
| 231 | else |
| 232 | #endif |
| 233 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 234 | mbedtls_printf("Do not know how to print key information for this type\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 235 | goto cleanup; |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 236 | } |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 237 | } |
| 238 | else if( opt.mode == MODE_PUBLIC ) |
| 239 | { |
| 240 | /* |
| 241 | * 1.1. Load the key |
| 242 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 243 | mbedtls_printf( "\n . Loading the public key ..." ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 244 | fflush( stdout ); |
| 245 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 246 | ret = mbedtls_pk_parse_public_keyfile( &pk, opt.filename ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 247 | |
| 248 | if( ret != 0 ) |
| 249 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 250 | mbedtls_printf( " failed\n ! mbedtls_pk_parse_public_keyfile returned -0x%04x\n", -ret ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 251 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 252 | } |
| 253 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 254 | mbedtls_printf( " ok\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 255 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 256 | mbedtls_printf( " . Key information ...\n" ); |
| 257 | #if defined(MBEDTLS_RSA_C) |
| 258 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_RSA ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 259 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 260 | mbedtls_rsa_context *rsa = mbedtls_pk_rsa( pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 261 | |
| 262 | if( ( ret = mbedtls_rsa_export( rsa, &N, NULL, NULL, |
| 263 | NULL, &E ) ) != 0 ) |
| 264 | { |
| 265 | mbedtls_printf( " failed\n ! could not export RSA parameters\n\n" ); |
Ron Eldor | 0d63e62 | 2018-06-27 08:49:00 +0300 | [diff] [blame] | 266 | goto cleanup; |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 267 | } |
Ron Eldor | 5146ef3 | 2018-06-27 11:51:46 +0300 | [diff] [blame] | 268 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "N: ", &N, 16, NULL ) ); |
| 269 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "E: ", &E, 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 270 | } |
| 271 | else |
| 272 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 273 | #if defined(MBEDTLS_ECP_C) |
| 274 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_ECKEY ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 275 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 276 | mbedtls_ecp_keypair *ecp = mbedtls_pk_ec( pk ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 277 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ) ); |
| 278 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ) ); |
| 279 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 280 | } |
| 281 | else |
| 282 | #endif |
| 283 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 284 | mbedtls_printf("Do not know how to print key information for this type\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 285 | goto cleanup; |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 286 | } |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 287 | } |
| 288 | else |
| 289 | goto usage; |
| 290 | |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 291 | exit_code = MBEDTLS_EXIT_SUCCESS; |
| 292 | |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 293 | cleanup: |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 294 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 295 | #if defined(MBEDTLS_ERROR_C) |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 296 | if( exit_code != MBEDTLS_EXIT_SUCCESS ) |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 297 | { |
Ron Eldor | 45486b1 | 2018-06-24 16:34:15 +0300 | [diff] [blame] | 298 | mbedtls_strerror( ret, buf, sizeof( buf ) ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 299 | mbedtls_printf( " ! Last error was: %s\n", buf ); |
| 300 | } |
Manuel Pégourié-Gonnard | 92e5b59 | 2013-09-18 18:57:10 +0200 | [diff] [blame] | 301 | #endif |
| 302 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 303 | mbedtls_pk_free( &pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 304 | mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q ); |
| 305 | mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &DP ); |
| 306 | mbedtls_mpi_free( &DQ ); mbedtls_mpi_free( &QP ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 307 | |
Paul Bakker | cce9d77 | 2011-11-18 14:26:47 +0000 | [diff] [blame] | 308 | #if defined(_WIN32) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 309 | mbedtls_printf( " + Press Enter to exit this program.\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 310 | fflush( stdout ); getchar(); |
| 311 | #endif |
| 312 | |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame^] | 313 | mbedtls_exit( exit_code ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 314 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 315 | #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_PK_PARSE_C && MBEDTLS_FS_IO */ |