blob: 85cdb7498c1c300aa404225079f9c82b13cfb0b9 [file] [log] [blame]
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +02001/* BEGIN_HEADER */
2#include <polarssl/pk.h>
3
4static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len );
5
6static int pk_genkey( pk_context *pk )
7{
Paul Bakkera5320902013-12-19 17:29:52 +01008 ((void) pk);
9
10#if defined(POLARSSL_RSA_C) && defined(POLARSSL_GENPRIME)
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020011 if( pk_get_type( pk ) == POLARSSL_PK_RSA )
12 return rsa_gen_key( pk_rsa( *pk ), rnd_std_rand, NULL, 512, 3 );
13#endif
14#if defined(POLARSSL_ECP_C)
15 if( pk_get_type( pk ) == POLARSSL_PK_ECKEY ||
16 pk_get_type( pk ) == POLARSSL_PK_ECKEY_DH ||
17 pk_get_type( pk ) == POLARSSL_PK_ECDSA )
18 {
19 int ret;
20 if( ( ret = ecp_use_known_dp( &pk_ec( *pk )->grp,
21 POLARSSL_ECP_DP_SECP192R1 ) ) != 0 )
22 return( ret );
23
24 return ecp_gen_keypair( &pk_ec( *pk )->grp, &pk_ec( *pk )->d,
25 &pk_ec( *pk )->Q, rnd_std_rand, NULL );
26 }
27#endif
28 return( -1 );
29}
30/* END_HEADER */
31
32/* BEGIN_DEPENDENCIES
33 * depends_on:POLARSSL_PK_C
34 * END_DEPENDENCIES
35 */
36
37/* BEGIN_CASE */
38void pk_utils( int type, int size, int len, char *name )
39{
40 pk_context pk;
41
42 pk_init( &pk );
43
44 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
45 TEST_ASSERT( pk_genkey( &pk ) == 0 );
46
47 TEST_ASSERT( (int) pk_get_type( &pk ) == type );
48 TEST_ASSERT( pk_can_do( &pk, type ) );
49 TEST_ASSERT( pk_get_size( &pk ) == (unsigned) size );
50 TEST_ASSERT( pk_get_len( &pk ) == (unsigned) len );
51 TEST_ASSERT( strcmp( pk_get_name( &pk), name ) == 0 );
52
53 pk_free( &pk );
54}
55/* END_CASE */
56
Manuel Pégourié-Gonnard748190d2013-10-17 13:13:07 +020057/* BEGIN_CASE depends_on:POLARSSL_RSA_C */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020058void pk_rsa_verify_test_vec( char *message_hex_string, int digest,
59 int mod, int radix_N, char *input_N, int radix_E,
60 char *input_E, char *result_hex_str, int result )
61{
62 unsigned char message_str[1000];
63 unsigned char hash_result[1000];
64 unsigned char result_str[1000];
65 rsa_context *rsa;
66 pk_context pk;
67 int msg_len;
68
69 pk_init( &pk );
70
71 memset( message_str, 0x00, 1000 );
72 memset( hash_result, 0x00, 1000 );
73 memset( result_str, 0x00, 1000 );
74
75 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
76 rsa = pk_rsa( pk );
77
78 rsa->len = mod / 8;
79 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
80 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
81
82 msg_len = unhexify( message_str, message_hex_string );
83 unhexify( result_str, result_hex_str );
84
85 if( md_info_from_type( digest ) != NULL )
86 TEST_ASSERT( md( md_info_from_type( digest ), message_str, msg_len, hash_result ) == 0 );
87
88 TEST_ASSERT( pk_verify( &pk, digest, hash_result, 0,
89 result_str, pk_get_len( &pk ) ) == result );
90
91 pk_free( &pk );
92}
93/* END_CASE */
94
95/* BEGIN_CASE depends_on:POLARSSL_ECDSA_C */
96void pk_ec_test_vec( int type, int id, char *key_str,
97 char *hash_str, char * sig_str, int ret )
98{
99 pk_context pk;
100 ecp_keypair *eckey;
101 unsigned char hash[100], sig[500], key[500];
102 size_t hash_len, sig_len, key_len;
103
104 pk_init( &pk );
105
106 memset( hash, 0, sizeof( hash ) ); hash_len = unhexify(hash, hash_str);
107 memset( sig, 0, sizeof( sig ) ); sig_len = unhexify(sig, sig_str);
108 memset( key, 0, sizeof( key ) ); key_len = unhexify(key, key_str);
109
110 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
111
112 TEST_ASSERT( pk_can_do( &pk, POLARSSL_PK_ECDSA ) );
113 eckey = pk_ec( pk );
114
115 TEST_ASSERT( ecp_use_known_dp( &eckey->grp, id ) == 0 );
116 TEST_ASSERT( ecp_point_read_binary( &eckey->grp, &eckey->Q,
117 key, key_len ) == 0 );
118
119 TEST_ASSERT( pk_verify( &pk, POLARSSL_MD_NONE,
120 hash, hash_len, sig, sig_len ) == ret );
121
122 pk_free( &pk );
123}
124/* END_CASE */
125
126/* BEGIN_CASE */
127void pk_sign_verify( int type, int sign_ret, int verify_ret )
128{
129 pk_context pk;
130 unsigned char hash[50], sig[5000];
131 size_t sig_len;
132
133 pk_init( &pk );
134
135 memset( hash, 0x2a, sizeof hash );
136 memset( sig, 0, sizeof sig );
137
138 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
139 TEST_ASSERT( pk_genkey( &pk ) == 0 );
140
141 TEST_ASSERT( pk_sign( &pk, POLARSSL_MD_NONE, hash, sizeof hash,
142 sig, &sig_len, rnd_std_rand, NULL ) == sign_ret );
143
144 TEST_ASSERT( pk_verify( &pk, POLARSSL_MD_NONE,
145 hash, sizeof hash, sig, sig_len ) == verify_ret );
146
147 pk_free( &pk );
148}
149/* END_CASE */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200150
151/* BEGIN_CASE depends_on:POLARSSL_RSA_C */
152void pk_rsa_encrypt_test_vec( char *message_hex, int mod,
153 int radix_N, char *input_N,
154 int radix_E, char *input_E,
155 char *result_hex, int ret )
156{
157 unsigned char message[1000];
158 unsigned char output[1000];
159 unsigned char result[1000];
160 size_t msg_len, olen, res_len;
161 rnd_pseudo_info rnd_info;
162 rsa_context *rsa;
163 pk_context pk;
164
165 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
166 memset( message, 0, sizeof( message ) );
167 memset( output, 0, sizeof( output ) );
168 memset( result, 0, sizeof( result ) );
169
170 msg_len = unhexify( message, message_hex );
171 res_len = unhexify( result, result_hex );
172
173 pk_init( &pk );
174 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
175 rsa = pk_rsa( pk );
176
177 rsa->len = mod / 8;
178 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
179 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
180
181 TEST_ASSERT( pk_encrypt( &pk, message, msg_len,
182 output, &olen, sizeof( output ),
183 rnd_pseudo_rand, &rnd_info ) == ret );
184 TEST_ASSERT( olen == res_len );
185 TEST_ASSERT( memcmp( output, result, olen ) == 0 );
186
187 pk_free( &pk );
188}
189/* END_CASE */
190
191/* BEGIN_CASE depends_on:POLARSSL_RSA_C */
192void pk_rsa_decrypt_test_vec( char *cipher_hex, int mod,
193 int radix_P, char *input_P,
194 int radix_Q, char *input_Q,
195 int radix_N, char *input_N,
196 int radix_E, char *input_E,
197 char *clear_hex, int ret )
198{
199 unsigned char clear[1000];
200 unsigned char output[1000];
201 unsigned char cipher[1000];
202 size_t clear_len, olen, cipher_len;
203 rnd_pseudo_info rnd_info;
204 mpi P1, Q1, H, G;
205 rsa_context *rsa;
206 pk_context pk;
207
208 pk_init( &pk );
209 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
210
211 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
212 memset( clear, 0, sizeof( clear ) );
213 memset( cipher, 0, sizeof( cipher ) );
214
215 clear_len = unhexify( clear, clear_hex );
216 cipher_len = unhexify( cipher, cipher_hex );
217
218 /* init pk-rsa context */
219 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
220 rsa = pk_rsa( pk );
221
222 /* load public key */
223 rsa->len = mod / 8;
224 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
225 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
226
227 /* load private key */
228 TEST_ASSERT( mpi_read_string( &rsa->P, radix_P, input_P ) == 0 );
229 TEST_ASSERT( mpi_read_string( &rsa->Q, radix_Q, input_Q ) == 0 );
230 TEST_ASSERT( mpi_sub_int( &P1, &rsa->P, 1 ) == 0 );
231 TEST_ASSERT( mpi_sub_int( &Q1, &rsa->Q, 1 ) == 0 );
232 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
233 TEST_ASSERT( mpi_gcd( &G, &rsa->E, &H ) == 0 );
234 TEST_ASSERT( mpi_inv_mod( &rsa->D , &rsa->E, &H ) == 0 );
235 TEST_ASSERT( mpi_mod_mpi( &rsa->DP, &rsa->D, &P1 ) == 0 );
236 TEST_ASSERT( mpi_mod_mpi( &rsa->DQ, &rsa->D, &Q1 ) == 0 );
237 TEST_ASSERT( mpi_inv_mod( &rsa->QP, &rsa->Q, &rsa->P ) == 0 );
238
239 /* decryption test */
240 memset( output, 0, sizeof( output ) );
241 olen = 0;
242 TEST_ASSERT( pk_decrypt( &pk, cipher, cipher_len,
243 output, &olen, sizeof( output ),
244 rnd_pseudo_rand, &rnd_info ) == ret );
245 if( ret == 0 )
246 {
247 TEST_ASSERT( olen == clear_len );
248 TEST_ASSERT( memcmp( output, clear, olen ) == 0 );
249 }
250
251 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
252 pk_free( &pk );
253}
254/* END_CASE */
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200255
256/* BEGIN_CASE */
257void pk_ec_nocrypt( int type )
258{
259 pk_context pk;
260 unsigned char output[100];
261 unsigned char input[100];
262 rnd_pseudo_info rnd_info;
263 size_t olen = 0;
264 int ret = POLARSSL_ERR_PK_TYPE_MISMATCH;
265
266 pk_init( &pk );
267
268 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
269 memset( output, 0, sizeof( output ) );
270 memset( input, 0, sizeof( input ) );
271
272 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
273
274 TEST_ASSERT( pk_encrypt( &pk, input, sizeof( input ),
275 output, &olen, sizeof( output ),
276 rnd_pseudo_rand, &rnd_info ) == ret );
277
278 TEST_ASSERT( pk_decrypt( &pk, input, sizeof( input ),
279 output, &olen, sizeof( output ),
280 rnd_pseudo_rand, &rnd_info ) == ret );
281
282 pk_free( &pk );
283}
284/* END_CASE */