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 |
Bence Szépkúti | 4e9f712 | 2020-06-05 13:02:18 +0200 | [diff] [blame^] | 5 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
| 6 | * |
| 7 | * This file is provided under the Apache License 2.0, or the |
| 8 | * GNU General Public License v2.0 or later. |
| 9 | * |
| 10 | * ********** |
| 11 | * Apache License 2.0: |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 12 | * |
| 13 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 14 | * not use this file except in compliance with the License. |
| 15 | * You may obtain a copy of the License at |
| 16 | * |
| 17 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 18 | * |
| 19 | * Unless required by applicable law or agreed to in writing, software |
| 20 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 21 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 22 | * See the License for the specific language governing permissions and |
| 23 | * limitations under the License. |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 24 | * |
Bence Szépkúti | 4e9f712 | 2020-06-05 13:02:18 +0200 | [diff] [blame^] | 25 | * ********** |
| 26 | * |
| 27 | * ********** |
| 28 | * GNU General Public License v2.0 or later: |
| 29 | * |
| 30 | * This program is free software; you can redistribute it and/or modify |
| 31 | * it under the terms of the GNU General Public License as published by |
| 32 | * the Free Software Foundation; either version 2 of the License, or |
| 33 | * (at your option) any later version. |
| 34 | * |
| 35 | * This program is distributed in the hope that it will be useful, |
| 36 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 37 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 38 | * GNU General Public License for more details. |
| 39 | * |
| 40 | * You should have received a copy of the GNU General Public License along |
| 41 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 42 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| 43 | * |
| 44 | * ********** |
| 45 | * |
Manuel Pégourié-Gonnard | fe44643 | 2015-03-06 13:17:10 +0000 | [diff] [blame] | 46 | * This file is part of mbed TLS (https://tls.mbed.org) |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 47 | */ |
| 48 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 49 | #if !defined(MBEDTLS_CONFIG_FILE) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 50 | #include "mbedtls/config.h" |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 51 | #else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 52 | #include MBEDTLS_CONFIG_FILE |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 53 | #endif |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 54 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 55 | #if defined(MBEDTLS_PLATFORM_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 56 | #include "mbedtls/platform.h" |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 57 | #else |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 58 | #include <stdio.h> |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 59 | #include <stdlib.h> |
| 60 | #define mbedtls_printf printf |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame] | 61 | #define mbedtls_exit exit |
Andres Amaya Garcia | 2b0599b | 2018-04-30 22:42:33 +0100 | [diff] [blame] | 62 | #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 63 | #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE |
| 64 | #endif /* MBEDTLS_PLATFORM_C */ |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 65 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 66 | #if defined(MBEDTLS_BIGNUM_C) && \ |
| 67 | defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_FS_IO) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 68 | #include "mbedtls/error.h" |
| 69 | #include "mbedtls/rsa.h" |
| 70 | #include "mbedtls/x509.h" |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 71 | |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 72 | #include <string.h> |
| 73 | #endif |
| 74 | |
| 75 | #define MODE_NONE 0 |
| 76 | #define MODE_PRIVATE 1 |
| 77 | #define MODE_PUBLIC 2 |
| 78 | |
| 79 | #define DFL_MODE MODE_NONE |
| 80 | #define DFL_FILENAME "keyfile.key" |
| 81 | #define DFL_PASSWORD "" |
| 82 | #define DFL_PASSWORD_FILE "" |
| 83 | #define DFL_DEBUG_LEVEL 0 |
Manuel Pégourié-Gonnard | 6c5abfa | 2015-02-13 14:12:07 +0000 | [diff] [blame] | 84 | |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 85 | #define USAGE \ |
| 86 | "\n usage: key_app param=<>...\n" \ |
| 87 | "\n acceptable parameters:\n" \ |
| 88 | " mode=private|public default: none\n" \ |
| 89 | " filename=%%s default: keyfile.key\n" \ |
| 90 | " password=%%s default: \"\"\n" \ |
| 91 | " password_file=%%s default: \"\"\n" \ |
| 92 | "\n" |
| 93 | |
| 94 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 95 | #if !defined(MBEDTLS_BIGNUM_C) || \ |
| 96 | !defined(MBEDTLS_PK_PARSE_C) || !defined(MBEDTLS_FS_IO) |
Rich Evans | 85b05ec | 2015-02-12 11:37:29 +0000 | [diff] [blame] | 97 | int main( void ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 98 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 99 | mbedtls_printf("MBEDTLS_BIGNUM_C and/or " |
| 100 | "MBEDTLS_PK_PARSE_C and/or MBEDTLS_FS_IO not defined.\n"); |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame] | 101 | mbedtls_exit( 0 ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 102 | } |
| 103 | #else |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 104 | /* |
| 105 | * global options |
| 106 | */ |
| 107 | struct options |
| 108 | { |
| 109 | int mode; /* the mode to run the application in */ |
Paul Bakker | ef3f8c7 | 2013-06-24 13:01:08 +0200 | [diff] [blame] | 110 | const char *filename; /* filename of the key file */ |
| 111 | const char *password; /* password for the private key */ |
| 112 | const char *password_file; /* password_file for the private key */ |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 113 | } opt; |
| 114 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 115 | int main( int argc, char *argv[] ) |
| 116 | { |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 117 | int ret = 1; |
| 118 | int exit_code = MBEDTLS_EXIT_FAILURE; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 119 | char buf[1024]; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 120 | int i; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 121 | char *p, *q; |
| 122 | |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 123 | mbedtls_pk_context pk; |
| 124 | mbedtls_mpi N, P, Q, D, E, DP, DQ, QP; |
| 125 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 126 | /* |
| 127 | * Set to sane values |
| 128 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 129 | mbedtls_pk_init( &pk ); |
Paul Bakker | 2e24ca7 | 2013-09-18 15:21:27 +0200 | [diff] [blame] | 130 | memset( buf, 0, sizeof(buf) ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 131 | |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 132 | mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q ); |
| 133 | mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &DP ); |
| 134 | mbedtls_mpi_init( &DQ ); mbedtls_mpi_init( &QP ); |
| 135 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 136 | if( argc == 0 ) |
| 137 | { |
| 138 | usage: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 139 | mbedtls_printf( USAGE ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 140 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | opt.mode = DFL_MODE; |
| 144 | opt.filename = DFL_FILENAME; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 145 | opt.password = DFL_PASSWORD; |
| 146 | opt.password_file = DFL_PASSWORD_FILE; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 147 | |
| 148 | for( i = 1; i < argc; i++ ) |
| 149 | { |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 150 | p = argv[i]; |
| 151 | if( ( q = strchr( p, '=' ) ) == NULL ) |
| 152 | goto usage; |
| 153 | *q++ = '\0'; |
| 154 | |
| 155 | if( strcmp( p, "mode" ) == 0 ) |
| 156 | { |
| 157 | if( strcmp( q, "private" ) == 0 ) |
| 158 | opt.mode = MODE_PRIVATE; |
| 159 | else if( strcmp( q, "public" ) == 0 ) |
| 160 | opt.mode = MODE_PUBLIC; |
| 161 | else |
| 162 | goto usage; |
| 163 | } |
| 164 | else if( strcmp( p, "filename" ) == 0 ) |
| 165 | opt.filename = q; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 166 | else if( strcmp( p, "password" ) == 0 ) |
| 167 | opt.password = q; |
| 168 | else if( strcmp( p, "password_file" ) == 0 ) |
| 169 | opt.password_file = q; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 170 | else |
| 171 | goto usage; |
| 172 | } |
| 173 | |
| 174 | if( opt.mode == MODE_PRIVATE ) |
| 175 | { |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 176 | if( strlen( opt.password ) && strlen( opt.password_file ) ) |
| 177 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 178 | mbedtls_printf( "Error: cannot have both password and password_file\n" ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 179 | goto usage; |
| 180 | } |
| 181 | |
| 182 | if( strlen( opt.password_file ) ) |
| 183 | { |
| 184 | FILE *f; |
| 185 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 186 | mbedtls_printf( "\n . Loading the password file ..." ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 187 | if( ( f = fopen( opt.password_file, "rb" ) ) == NULL ) |
| 188 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 189 | mbedtls_printf( " failed\n ! fopen returned NULL\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 190 | goto cleanup; |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 191 | } |
Paul Bakker | 8a0c0a9 | 2014-04-17 16:08:20 +0200 | [diff] [blame] | 192 | if( fgets( buf, sizeof(buf), f ) == NULL ) |
| 193 | { |
| 194 | fclose( f ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 195 | mbedtls_printf( "Error: fgets() failed to retrieve password\n" ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 196 | goto cleanup; |
Paul Bakker | 8a0c0a9 | 2014-04-17 16:08:20 +0200 | [diff] [blame] | 197 | } |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 198 | fclose( f ); |
| 199 | |
Paul Bakker | 840ab20 | 2013-11-30 15:14:38 +0100 | [diff] [blame] | 200 | i = (int) strlen( buf ); |
Paul Bakker | db2509c | 2012-09-27 12:44:31 +0000 | [diff] [blame] | 201 | if( buf[i - 1] == '\n' ) buf[i - 1] = '\0'; |
| 202 | if( buf[i - 2] == '\r' ) buf[i - 2] = '\0'; |
| 203 | opt.password = buf; |
| 204 | } |
| 205 | |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 206 | /* |
| 207 | * 1.1. Load the key |
| 208 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 209 | mbedtls_printf( "\n . Loading the private key ..." ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 210 | fflush( stdout ); |
| 211 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 212 | ret = mbedtls_pk_parse_keyfile( &pk, opt.filename, opt.password ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 213 | |
| 214 | if( ret != 0 ) |
| 215 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 216 | 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] | 217 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 218 | } |
| 219 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 220 | mbedtls_printf( " ok\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 221 | |
| 222 | /* |
| 223 | * 1.2 Print the key |
| 224 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 225 | mbedtls_printf( " . Key information ...\n" ); |
| 226 | #if defined(MBEDTLS_RSA_C) |
| 227 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_RSA ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 228 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 229 | mbedtls_rsa_context *rsa = mbedtls_pk_rsa( pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 230 | |
| 231 | if( ( ret = mbedtls_rsa_export ( rsa, &N, &P, &Q, &D, &E ) ) != 0 || |
| 232 | ( ret = mbedtls_rsa_export_crt( rsa, &DP, &DQ, &QP ) ) != 0 ) |
| 233 | { |
| 234 | mbedtls_printf( " failed\n ! could not export RSA parameters\n\n" ); |
Ron Eldor | 0d63e62 | 2018-06-27 08:49:00 +0300 | [diff] [blame] | 235 | goto cleanup; |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 236 | } |
| 237 | |
Ron Eldor | 5146ef3 | 2018-06-27 11:51:46 +0300 | [diff] [blame] | 238 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "N: ", &N, 16, NULL ) ); |
| 239 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "E: ", &E, 16, NULL ) ); |
| 240 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "D: ", &D, 16, NULL ) ); |
| 241 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "P: ", &P, 16, NULL ) ); |
| 242 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q: ", &Q, 16, NULL ) ); |
| 243 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "DP: ", &DP, 16, NULL ) ); |
| 244 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "DQ: ", &DQ, 16, NULL ) ); |
| 245 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "QP: ", &QP, 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 246 | } |
| 247 | else |
| 248 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 249 | #if defined(MBEDTLS_ECP_C) |
| 250 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_ECKEY ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 251 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 252 | mbedtls_ecp_keypair *ecp = mbedtls_pk_ec( pk ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 253 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ) ); |
| 254 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ) ); |
| 255 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ) ); |
| 256 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "D : ", &ecp->d , 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 257 | } |
| 258 | else |
| 259 | #endif |
| 260 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 261 | 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] | 262 | goto cleanup; |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 263 | } |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 264 | } |
| 265 | else if( opt.mode == MODE_PUBLIC ) |
| 266 | { |
| 267 | /* |
| 268 | * 1.1. Load the key |
| 269 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 270 | mbedtls_printf( "\n . Loading the public key ..." ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 271 | fflush( stdout ); |
| 272 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 273 | ret = mbedtls_pk_parse_public_keyfile( &pk, opt.filename ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 274 | |
| 275 | if( ret != 0 ) |
| 276 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 277 | 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] | 278 | goto cleanup; |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 279 | } |
| 280 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 281 | mbedtls_printf( " ok\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 282 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 283 | mbedtls_printf( " . Key information ...\n" ); |
| 284 | #if defined(MBEDTLS_RSA_C) |
| 285 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_RSA ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 286 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 287 | mbedtls_rsa_context *rsa = mbedtls_pk_rsa( pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 288 | |
| 289 | if( ( ret = mbedtls_rsa_export( rsa, &N, NULL, NULL, |
| 290 | NULL, &E ) ) != 0 ) |
| 291 | { |
| 292 | mbedtls_printf( " failed\n ! could not export RSA parameters\n\n" ); |
Ron Eldor | 0d63e62 | 2018-06-27 08:49:00 +0300 | [diff] [blame] | 293 | goto cleanup; |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 294 | } |
Ron Eldor | 5146ef3 | 2018-06-27 11:51:46 +0300 | [diff] [blame] | 295 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "N: ", &N, 16, NULL ) ); |
| 296 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "E: ", &E, 16, NULL ) ); |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 297 | } |
| 298 | else |
| 299 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 300 | #if defined(MBEDTLS_ECP_C) |
| 301 | if( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_ECKEY ) |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 302 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 303 | mbedtls_ecp_keypair *ecp = mbedtls_pk_ec( pk ); |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 304 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ) ); |
| 305 | MBEDTLS_MPI_CHK( mbedtls_mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ) ); |
| 306 | 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] | 307 | } |
| 308 | else |
| 309 | #endif |
| 310 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 311 | 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] | 312 | goto cleanup; |
Paul Bakker | 1525495 | 2013-09-17 11:24:56 +0200 | [diff] [blame] | 313 | } |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 314 | } |
| 315 | else |
| 316 | goto usage; |
| 317 | |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 318 | exit_code = MBEDTLS_EXIT_SUCCESS; |
| 319 | |
Ron Eldor | e144089 | 2017-08-24 14:20:17 +0300 | [diff] [blame] | 320 | cleanup: |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 321 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 322 | #if defined(MBEDTLS_ERROR_C) |
Andres Amaya Garcia | f57bccf | 2018-04-29 20:02:18 +0100 | [diff] [blame] | 323 | if( exit_code != MBEDTLS_EXIT_SUCCESS ) |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 324 | { |
Ron Eldor | 45486b1 | 2018-06-24 16:34:15 +0300 | [diff] [blame] | 325 | mbedtls_strerror( ret, buf, sizeof( buf ) ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 326 | mbedtls_printf( " ! Last error was: %s\n", buf ); |
| 327 | } |
Manuel Pégourié-Gonnard | 92e5b59 | 2013-09-18 18:57:10 +0200 | [diff] [blame] | 328 | #endif |
| 329 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 330 | mbedtls_pk_free( &pk ); |
Hanno Becker | 54ebf99 | 2017-08-23 06:45:38 +0100 | [diff] [blame] | 331 | mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q ); |
| 332 | mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &DP ); |
| 333 | mbedtls_mpi_free( &DQ ); mbedtls_mpi_free( &QP ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 334 | |
Paul Bakker | cce9d77 | 2011-11-18 14:26:47 +0000 | [diff] [blame] | 335 | #if defined(_WIN32) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 336 | mbedtls_printf( " + Press Enter to exit this program.\n" ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 337 | fflush( stdout ); getchar(); |
| 338 | #endif |
| 339 | |
Krzysztof Stachowiak | a086522 | 2019-04-24 14:24:46 +0200 | [diff] [blame] | 340 | mbedtls_exit( exit_code ); |
Paul Bakker | ed56b22 | 2011-07-13 11:26:43 +0000 | [diff] [blame] | 341 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 342 | #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_PK_PARSE_C && MBEDTLS_FS_IO */ |