TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / 8101cd2fc6c158d1b2ea618cddde6c91e7a49f0d / . / tests / suites / test_suite_pkcs1_v21.function
blob: 8885e8b3ecca40d6f53ba1b0c95f224d5aebad16 [file] [log] [blame]
Paul Bakker9dcc3222011-03-08 14:16:06 +0000[diff] [blame]1BEGIN_HEADER
Paul Bakker9dcc3222011-03-08 14:16:06 +0000[diff] [blame]2#include <polarssl/rsa.h>
3#include <polarssl/md.h>
4#include <polarssl/md2.h>
5#include <polarssl/md4.h>
6#include <polarssl/md5.h>
7#include <polarssl/sha1.h>
8#include <polarssl/sha2.h>
9#include <polarssl/sha4.h>
10END_HEADER
11
12BEGIN_CASE
13pkcs1_rsaes_oaep_encrypt:mod:radix_N:input_N:radix_E:input_E:hash:message_hex_string:seed:result_hex_str:result
14{
15 unsigned char message_str[1000];
16 unsigned char output[1000];
17 unsigned char output_str[1000];
18 unsigned char rnd_buf[1000];
19 rsa_context ctx;
20 int msg_len;
Paul Bakker4cce2bb2011-03-13 16:56:35 +0000[diff] [blame]21 rnd_buf_info info;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000[diff] [blame]22
23 info.length = unhexify( rnd_buf, {seed} );
24 info.buf = rnd_buf;
25 info.per_call = 1;
26
27 rsa_init( &ctx, RSA_PKCS_V21, {hash} );
28 memset( message_str, 0x00, 1000 );
29 memset( output, 0x00, 1000 );
30 memset( output_str, 0x00, 1000 );
31
32 ctx.len = {mod} / 8 + ( ( {mod} % 8 ) ? 1 : 0 );
33 TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
34 TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
35
36 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
37
38 msg_len = unhexify( message_str, {message_hex_string} );
39
40 TEST_ASSERT( rsa_pkcs1_encrypt( &ctx, &rnd_buffer_rand, &info, RSA_PUBLIC, msg_len, message_str, output ) == {result} );
41 if( {result} == 0 )
42 {
43 hexify( output_str, output, ctx.len );
44
45 TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
46 }
47}
48END_CASE
49
50BEGIN_CASE
51pkcs1_rsaes_oaep_decrypt:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:hash:result_hex_str:seed:message_hex_string:result
52{
53 unsigned char message_str[1000];
54 unsigned char output[1000];
55 unsigned char output_str[1000];
56 rsa_context ctx;
57 mpi P1, Q1, H, G;
58 int output_len;
59 int msg_len;
60
61 mpi_init( &P1, &Q1, &H, &G, NULL );
62 rsa_init( &ctx, RSA_PKCS_V21, {hash} );
63
64 memset( message_str, 0x00, 1000 );
65 memset( output, 0x00, 1000 );
66 memset( output_str, 0x00, 1000 );
67
68 ctx.len = {mod} / 8 + ( ( {mod} % 8 ) ? 1 : 0 );
69 TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
70 TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
71 TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
72 TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
73
74 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
75 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
76 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
77 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
78 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
79 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
80 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
81 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
82
83 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
84
85 msg_len = unhexify( message_str, {message_hex_string} );
86
87 TEST_ASSERT( rsa_pkcs1_decrypt( &ctx, RSA_PRIVATE, &output_len, message_str, output, 1000 ) == {result} );
88 if( {result} == 0 )
89 {
90 hexify( output_str, output, ctx.len );
91
92 TEST_ASSERT( strncasecmp( (char *) output_str, {result_hex_str}, strlen( {result_hex_str} ) ) == 0 );
93 }
94}
95END_CASE
96
97BEGIN_CASE
98pkcs1_rsassa_pss_sign:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:digest:hash:message_hex_string:salt:result_hex_str:result
99{
100 unsigned char message_str[1000];
101 unsigned char hash_result[1000];
102 unsigned char output[1000];
103 unsigned char output_str[1000];
104 unsigned char rnd_buf[1000];
105 rsa_context ctx;
106 mpi P1, Q1, H, G;
107 int msg_len;
Paul Bakker4cce2bb2011-03-13 16:56:35 +0000[diff] [blame]108 rnd_buf_info info;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000[diff] [blame]109
110 info.length = unhexify( rnd_buf, {salt} );
111 info.buf = rnd_buf;
112 info.per_call = 1;
113
114 mpi_init( &P1, &Q1, &H, &G, NULL );
115 rsa_init( &ctx, RSA_PKCS_V21, {hash} );
116
117 memset( message_str, 0x00, 1000 );
118 memset( hash_result, 0x00, 1000 );
119 memset( output, 0x00, 1000 );
120 memset( output_str, 0x00, 1000 );
121
122 ctx.len = {mod} / 8 + ( ( {mod} % 8 ) ? 1 : 0 );
123 TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
124 TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
125 TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
126 TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
127
128 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
129 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
130 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
131 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
132 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
133 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
134 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
135 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
136
137 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
138
139 msg_len = unhexify( message_str, {message_hex_string} );
140
141 switch( {digest} )
142 {
143#ifdef POLARSSL_MD2_C
144 case SIG_RSA_MD2:
145 md2( message_str, msg_len, hash_result );
146 break;
147#endif
148#ifdef POLARSSL_MD4_C
149 case SIG_RSA_MD4:
150 md4( message_str, msg_len, hash_result );
151 break;
152#endif
153#ifdef POLARSSL_MD5_C
154 case SIG_RSA_MD5:
155 md5( message_str, msg_len, hash_result );
156 break;
157#endif
158#ifdef POLARSSL_SHA1_C
159 case SIG_RSA_SHA1:
160 sha1( message_str, msg_len, hash_result );
161 break;
162#endif
163#ifdef POLARSSL_SHA2_C
164 case SIG_RSA_SHA224:
165 sha2( message_str, msg_len, hash_result, 1 );
166 break;
167 case SIG_RSA_SHA256:
168 sha2( message_str, msg_len, hash_result, 0 );
169 break;
170#endif
171#ifdef POLARSSL_SHA4_C
172 case SIG_RSA_SHA384:
173 sha4( message_str, msg_len, hash_result, 1 );
174 break;
175 case SIG_RSA_SHA512:
176 sha4( message_str, msg_len, hash_result, 0 );
177 break;
178#endif
179 }
180
181 TEST_ASSERT( rsa_pkcs1_sign( &ctx, &rnd_buffer_rand, &info, RSA_PRIVATE, {digest}, 0, hash_result, output ) == {result} );
182 if( {result} == 0 )
183 {
184 hexify( output_str, output, ctx.len);
185
186 TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
187 }
188}
189END_CASE
190
191BEGIN_CASE
192pkcs1_rsassa_pss_verify:mod:radix_N:input_N:radix_E:input_E:digest:hash:message_hex_string:salt:result_hex_str:result
193{
194 unsigned char message_str[1000];
195 unsigned char hash_result[1000];
196 unsigned char result_str[1000];
197 rsa_context ctx;
198 int msg_len;
199
200 rsa_init( &ctx, RSA_PKCS_V21, {hash} );
201 memset( message_str, 0x00, 1000 );
202 memset( hash_result, 0x00, 1000 );
203 memset( result_str, 0x00, 1000 );
204
205 ctx.len = {mod} / 8 + ( ( {mod} % 8 ) ? 1 : 0 );
206 TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
207 TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
208
209 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
210
211 msg_len = unhexify( message_str, {message_hex_string} );
212 unhexify( result_str, {result_hex_str} );
213
214 switch( {digest} )
215 {
216#ifdef POLARSSL_MD2_C
217 case SIG_RSA_MD2:
218 md2( message_str, msg_len, hash_result );
219 break;
220#endif
221#ifdef POLARSSL_MD4_C
222 case SIG_RSA_MD4:
223 md4( message_str, msg_len, hash_result );
224 break;
225#endif
226#ifdef POLARSSL_MD5_C
227 case SIG_RSA_MD5:
228 md5( message_str, msg_len, hash_result );
229 break;
230#endif
231#ifdef POLARSSL_SHA1_C
232 case SIG_RSA_SHA1:
233 sha1( message_str, msg_len, hash_result );
234 break;
235#endif
236#ifdef POLARSSL_SHA2_C
237 case SIG_RSA_SHA224:
238 sha2( message_str, msg_len, hash_result, 1 );
239 break;
240 case SIG_RSA_SHA256:
241 sha2( message_str, msg_len, hash_result, 0 );
242 break;
243#endif
244#ifdef POLARSSL_SHA4_C
245 case SIG_RSA_SHA384:
246 sha4( message_str, msg_len, hash_result, 1 );
247 break;
248 case SIG_RSA_SHA512:
249 sha4( message_str, msg_len, hash_result, 0 );
250 break;
251#endif
252 }
253
254 TEST_ASSERT( rsa_pkcs1_verify( &ctx, RSA_PUBLIC, {digest}, 0, hash_result, result_str ) == {result} );
255}
256END_CASE