Mercurial > dropbear

comparison libtomcrypt/tests/rsa_test.c @ 1478:3a933956437e coverity

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update coverity
author Matt Johnston <matt@ucc.asn.au>
date Fri, 09 Feb 2018 23:49:22 +0800
parents 6dba84798cd5
children
comparison
equal deleted inserted replaced
1439:8d24733026c5 1478:3a933956437e
1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
2 *
3 * LibTomCrypt is a library that provides various cryptographic
4 * algorithms in a highly modular and flexible manner.
5 *
6 * The library is free for all purposes without any express
7 * guarantee it works.
8 */
9 #include <tomcrypt_test.h>
10
11 #if defined(LTC_MRSA) && defined(LTC_TEST_MPI)
12
13 #define RSA_MSGSIZE 78
14
15 /* These are test keys [see file test.key] that I use to test my import/export against */
16 static const unsigned char openssl_private_rsa[] = {
17 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde, 0x64, 0x8a,
18 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7, 0xa1, 0xb7,
19 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96, 0x65, 0xe5,
20 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28, 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60, 0x12, 0x8a,
21 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b, 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b, 0xbf, 0x12,
22 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc, 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68, 0x7c, 0x61,
23 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe, 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4, 0xe2, 0x76,
24 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58, 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a, 0x60, 0x3f,
25 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31, 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01, 0x00, 0x01,
26 0x02, 0x81, 0x81, 0x00, 0xc8, 0x62, 0xb9, 0xea, 0xde, 0x44, 0x53, 0x1d, 0x56, 0x97, 0xd9, 0x97,
27 0x9e, 0x1a, 0xcf, 0x30, 0x1e, 0x0a, 0x88, 0x45, 0x86, 0x29, 0x30, 0xa3, 0x4d, 0x9f, 0x61, 0x65,
28 0x73, 0xe0, 0xd6, 0x87, 0x8f, 0xb6, 0xf3, 0x06, 0xa3, 0x82, 0xdc, 0x7c, 0xac, 0xfe, 0x9b, 0x28,
29 0x9a, 0xae, 0xfd, 0xfb, 0xfe, 0x2f, 0x0e, 0xd8, 0x97, 0x04, 0xe3, 0xbb, 0x1f, 0xd1, 0xec, 0x0d,
30 0xba, 0xa3, 0x49, 0x7f, 0x47, 0xac, 0x8a, 0x44, 0x04, 0x7e, 0x86, 0xb7, 0x39, 0x42, 0x3f, 0xad,
31 0x1e, 0xb7, 0x0e, 0xa5, 0x51, 0xf4, 0x40, 0x63, 0x1e, 0xfd, 0xbd, 0xea, 0x9f, 0x41, 0x9f, 0xa8,
32 0x90, 0x1d, 0x6f, 0x0a, 0x5a, 0x95, 0x13, 0x11, 0x0d, 0x80, 0xaf, 0x5f, 0x64, 0x98, 0x8a, 0x2c,
33 0x78, 0x68, 0x65, 0xb0, 0x2b, 0x8b, 0xa2, 0x53, 0x87, 0xca, 0xf1, 0x64, 0x04, 0xab, 0xf2, 0x7b,
34 0xdb, 0x83, 0xc8, 0x81, 0x02, 0x41, 0x00, 0xf7, 0xbe, 0x5e, 0x23, 0xc3, 0x32, 0x3f, 0xbf, 0x8b,
35 0x8e, 0x3a, 0xee, 0xfc, 0xfc, 0xcb, 0xe5, 0xf7, 0xf1, 0x0b, 0xbc, 0x42, 0x82, 0xae, 0xd5, 0x7a,
36 0x3e, 0xca, 0xf7, 0xd5, 0x69, 0x3f, 0x64, 0x25, 0xa2, 0x1f, 0xb7, 0x75, 0x75, 0x05, 0x92, 0x42,
37 0xeb, 0xb8, 0xf1, 0xf3, 0x0a, 0x05, 0xe3, 0x94, 0xd1, 0x55, 0x78, 0x35, 0xa0, 0x36, 0xa0, 0x9b,
38 0x7c, 0x92, 0x84, 0x6c, 0xdd, 0xdc, 0x4d, 0x02, 0x41, 0x00, 0xd6, 0x86, 0x0e, 0x85, 0x42, 0x0b,
39 0x04, 0x08, 0x84, 0x21, 0x60, 0xf0, 0x0e, 0x0d, 0x88, 0xfd, 0x1e, 0x36, 0x10, 0x65, 0x4f, 0x1e,
40 0x53, 0xb4, 0x08, 0x72, 0x80, 0x5c, 0x3f, 0x59, 0x66, 0x17, 0xe6, 0x98, 0xf2, 0xe9, 0x6c, 0x7a,
41 0x06, 0x4c, 0xac, 0x76, 0x3d, 0xed, 0x8c, 0xa1, 0xce, 0xad, 0x1b, 0xbd, 0xb4, 0x7d, 0x28, 0xbc,
42 0xe3, 0x0e, 0x38, 0x8d, 0x99, 0xd8, 0x05, 0xb5, 0xa3, 0x71, 0x02, 0x40, 0x6d, 0xeb, 0xc3, 0x2d,
43 0x2e, 0xf0, 0x5e, 0xa4, 0x88, 0x31, 0x05, 0x29, 0x00, 0x8a, 0xd1, 0x95, 0x29, 0x9b, 0x83, 0xcf,
44 0x75, 0xdb, 0x31, 0xe3, 0x7a, 0x27, 0xde, 0x3a, 0x74, 0x30, 0x0c, 0x76, 0x4c, 0xd4, 0x50, 0x2a,
45 0x40, 0x2d, 0x39, 0xd9, 0x99, 0x63, 0xa9, 0x5d, 0x80, 0xae, 0x53, 0xca, 0x94, 0x3f, 0x05, 0x23,
46 0x1e, 0xf8, 0x05, 0x04, 0xe1, 0xb8, 0x35, 0xf2, 0x17, 0xb3, 0xa0, 0x89, 0x02, 0x41, 0x00, 0xab,
47 0x90, 0x88, 0xfa, 0x60, 0x08, 0x29, 0x50, 0x9a, 0x43, 0x8b, 0xa0, 0x50, 0xcc, 0xd8, 0x5a, 0xfe,
48 0x97, 0x64, 0x63, 0x71, 0x74, 0x22, 0xa3, 0x20, 0x02, 0x5a, 0xcf, 0xeb, 0xc6, 0x16, 0x95, 0x54,
49 0xd1, 0xcb, 0xab, 0x8d, 0x1a, 0xc6, 0x00, 0xfa, 0x08, 0x92, 0x9c, 0x71, 0xd5, 0x52, 0x52, 0x35,
50 0x96, 0x71, 0x4b, 0x8b, 0x92, 0x0c, 0xd0, 0xe9, 0xbf, 0xad, 0x63, 0x0b, 0xa5, 0xe9, 0xb1, 0x02,
51 0x41, 0x00, 0xdc, 0xcc, 0x27, 0xc8, 0xe4, 0xdc, 0x62, 0x48, 0xd5, 0x9b, 0xaf, 0xf5, 0xab, 0x60,
52 0xf6, 0x21, 0xfd, 0x53, 0xe2, 0xb7, 0x5d, 0x09, 0xc9, 0x1a, 0xa1, 0x04, 0xa9, 0xfc, 0x61, 0x2c,
53 0x5d, 0x04, 0x58, 0x3a, 0x5a, 0x39, 0xf1, 0x4a, 0x21, 0x56, 0x67, 0xfd, 0xcc, 0x20, 0xa3, 0x8f,
54 0x78, 0x18, 0x5a, 0x79, 0x3d, 0x2e, 0x8e, 0x7e, 0x86, 0x0a, 0xe6, 0xa8, 0x33, 0xc1, 0x04, 0x17,
55 0x4a, 0x9f, };
56
57 static const unsigned char x509_public_rsa[] =
58 "MIICdTCCAd4CCQCYjCwz0l9JpjANBgkqhkiG9w0BAQsFADB+MQswCQYDVQQGEwJD\
59 WjEPMA0GA1UECAwGTW9yYXZhMQ0wCwYDVQQHDARCcm5vMRAwDgYDVQQKDAdMVEMg\
60 THRkMQ8wDQYDVQQLDAZDcnlwdG8xEjAQBgNVBAMMCVRlc3QgQ2VydDEYMBYGCSqG\
61 SIb3DQEJARYJdGVzdEBjZXJ0MCAXDTE3MDMwOTIzNDMzOVoYDzIyOTAxMjIyMjM0\
62 MzM5WjB+MQswCQYDVQQGEwJDWjEPMA0GA1UECAwGTW9yYXZhMQ0wCwYDVQQHDARC\
63 cm5vMRAwDgYDVQQKDAdMVEMgTHRkMQ8wDQYDVQQLDAZDcnlwdG8xEjAQBgNVBAMM\
64 CVRlc3QgQ2VydDEYMBYGCSqGSIb3DQEJARYJdGVzdEBjZXJ0MIGfMA0GCSqGSIb3\
65 DQEBAQUAA4GNADCBiQKBgQDPmt5kitrIMyCp14MxGVSymoWnobd1M7aprIQks97b\
66 fYUtlmXlP3KVJJ8oaMpP20QcPmASit0mpev/C17UiDhJKm5bvxI3R70Fa7zb8+7k\
67 EY5BaHxhE9dCyIC+No/cCItPrKTidgzJY2xJWJPtzKrcJTsKYD+LVDrDTTHnlKRE\
68 /QIDAQABMA0GCSqGSIb3DQEBCwUAA4GBAApwWqupmmLGHeKOLFLcthQpAXXYep6T\
69 3S3e8X7fIG6TGhfvn5DHn+/V/C4184oOCwImI+VYRokdXdQ1AMGfVUomHJxsFPia\
70 bv5Aw3hiKsIG3jigKHwmMScgkl3yn+8hLkx6thNbqQoa6Yyo20RqaEFBwlZ5G8lF\
71 rZsdeO84SeCH";
72
73 static const unsigned char pkcs8_private_rsa[] = {
74 0x30, 0x82, 0x02, 0x78, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
75 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x02, 0x62, 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01,
76 0x00, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde, 0x64, 0x8a, 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7,
77 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7, 0xa1, 0xb7, 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84,
78 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96, 0x65, 0xe5, 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28,
79 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60, 0x12, 0x8a, 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b,
80 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b, 0xbf, 0x12, 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc,
81 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68, 0x7c, 0x61, 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe,
82 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4, 0xe2, 0x76, 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58,
83 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a, 0x60, 0x3f, 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31,
84 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x81, 0x81, 0x00, 0xc8, 0x62,
85 0xb9, 0xea, 0xde, 0x44, 0x53, 0x1d, 0x56, 0x97, 0xd9, 0x97, 0x9e, 0x1a, 0xcf, 0x30, 0x1e, 0x0a,
86 0x88, 0x45, 0x86, 0x29, 0x30, 0xa3, 0x4d, 0x9f, 0x61, 0x65, 0x73, 0xe0, 0xd6, 0x87, 0x8f, 0xb6,
87 0xf3, 0x06, 0xa3, 0x82, 0xdc, 0x7c, 0xac, 0xfe, 0x9b, 0x28, 0x9a, 0xae, 0xfd, 0xfb, 0xfe, 0x2f,
88 0x0e, 0xd8, 0x97, 0x04, 0xe3, 0xbb, 0x1f, 0xd1, 0xec, 0x0d, 0xba, 0xa3, 0x49, 0x7f, 0x47, 0xac,
89 0x8a, 0x44, 0x04, 0x7e, 0x86, 0xb7, 0x39, 0x42, 0x3f, 0xad, 0x1e, 0xb7, 0x0e, 0xa5, 0x51, 0xf4,
90 0x40, 0x63, 0x1e, 0xfd, 0xbd, 0xea, 0x9f, 0x41, 0x9f, 0xa8, 0x90, 0x1d, 0x6f, 0x0a, 0x5a, 0x95,
91 0x13, 0x11, 0x0d, 0x80, 0xaf, 0x5f, 0x64, 0x98, 0x8a, 0x2c, 0x78, 0x68, 0x65, 0xb0, 0x2b, 0x8b,
92 0xa2, 0x53, 0x87, 0xca, 0xf1, 0x64, 0x04, 0xab, 0xf2, 0x7b, 0xdb, 0x83, 0xc8, 0x81, 0x02, 0x41,
93 0x00, 0xf7, 0xbe, 0x5e, 0x23, 0xc3, 0x32, 0x3f, 0xbf, 0x8b, 0x8e, 0x3a, 0xee, 0xfc, 0xfc, 0xcb,
94 0xe5, 0xf7, 0xf1, 0x0b, 0xbc, 0x42, 0x82, 0xae, 0xd5, 0x7a, 0x3e, 0xca, 0xf7, 0xd5, 0x69, 0x3f,
95 0x64, 0x25, 0xa2, 0x1f, 0xb7, 0x75, 0x75, 0x05, 0x92, 0x42, 0xeb, 0xb8, 0xf1, 0xf3, 0x0a, 0x05,
96 0xe3, 0x94, 0xd1, 0x55, 0x78, 0x35, 0xa0, 0x36, 0xa0, 0x9b, 0x7c, 0x92, 0x84, 0x6c, 0xdd, 0xdc,
97 0x4d, 0x02, 0x41, 0x00, 0xd6, 0x86, 0x0e, 0x85, 0x42, 0x0b, 0x04, 0x08, 0x84, 0x21, 0x60, 0xf0,
98 0x0e, 0x0d, 0x88, 0xfd, 0x1e, 0x36, 0x10, 0x65, 0x4f, 0x1e, 0x53, 0xb4, 0x08, 0x72, 0x80, 0x5c,
99 0x3f, 0x59, 0x66, 0x17, 0xe6, 0x98, 0xf2, 0xe9, 0x6c, 0x7a, 0x06, 0x4c, 0xac, 0x76, 0x3d, 0xed,
100 0x8c, 0xa1, 0xce, 0xad, 0x1b, 0xbd, 0xb4, 0x7d, 0x28, 0xbc, 0xe3, 0x0e, 0x38, 0x8d, 0x99, 0xd8,
101 0x05, 0xb5, 0xa3, 0x71, 0x02, 0x40, 0x6d, 0xeb, 0xc3, 0x2d, 0x2e, 0xf0, 0x5e, 0xa4, 0x88, 0x31,
102 0x05, 0x29, 0x00, 0x8a, 0xd1, 0x95, 0x29, 0x9b, 0x83, 0xcf, 0x75, 0xdb, 0x31, 0xe3, 0x7a, 0x27,
103 0xde, 0x3a, 0x74, 0x30, 0x0c, 0x76, 0x4c, 0xd4, 0x50, 0x2a, 0x40, 0x2d, 0x39, 0xd9, 0x99, 0x63,
104 0xa9, 0x5d, 0x80, 0xae, 0x53, 0xca, 0x94, 0x3f, 0x05, 0x23, 0x1e, 0xf8, 0x05, 0x04, 0xe1, 0xb8,
105 0x35, 0xf2, 0x17, 0xb3, 0xa0, 0x89, 0x02, 0x41, 0x00, 0xab, 0x90, 0x88, 0xfa, 0x60, 0x08, 0x29,
106 0x50, 0x9a, 0x43, 0x8b, 0xa0, 0x50, 0xcc, 0xd8, 0x5a, 0xfe, 0x97, 0x64, 0x63, 0x71, 0x74, 0x22,
107 0xa3, 0x20, 0x02, 0x5a, 0xcf, 0xeb, 0xc6, 0x16, 0x95, 0x54, 0xd1, 0xcb, 0xab, 0x8d, 0x1a, 0xc6,
108 0x00, 0xfa, 0x08, 0x92, 0x9c, 0x71, 0xd5, 0x52, 0x52, 0x35, 0x96, 0x71, 0x4b, 0x8b, 0x92, 0x0c,
109 0xd0, 0xe9, 0xbf, 0xad, 0x63, 0x0b, 0xa5, 0xe9, 0xb1, 0x02, 0x41, 0x00, 0xdc, 0xcc, 0x27, 0xc8,
110 0xe4, 0xdc, 0x62, 0x48, 0xd5, 0x9b, 0xaf, 0xf5, 0xab, 0x60, 0xf6, 0x21, 0xfd, 0x53, 0xe2, 0xb7,
111 0x5d, 0x09, 0xc9, 0x1a, 0xa1, 0x04, 0xa9, 0xfc, 0x61, 0x2c, 0x5d, 0x04, 0x58, 0x3a, 0x5a, 0x39,
112 0xf1, 0x4a, 0x21, 0x56, 0x67, 0xfd, 0xcc, 0x20, 0xa3, 0x8f, 0x78, 0x18, 0x5a, 0x79, 0x3d, 0x2e,
113 0x8e, 0x7e, 0x86, 0x0a, 0xe6, 0xa8, 0x33, 0xc1, 0x04, 0x17, 0x4a, 0x9f };
114
115 /* private key - hexadecimal */
116 enum {
117 pk_d ,
118 pk_dP,
119 pk_dQ,
120 pk_e ,
121 pk_N ,
122 pk_p ,
123 pk_q ,
124 pk_qP,
125 };
126 static const char *hex_key[] = {
127 "C862B9EADE44531D5697D9979E1ACF301E0A8845862930A34D9F616573E0D6878FB6F306A382DC7CACFE9B289AAEFDFBFE2F0ED89704E3BB1FD1EC0DBAA3497F47AC8A44047E86B739423FAD1EB70EA551F440631EFDBDEA9F419FA8901D6F0A5A9513110D80AF5F64988A2C786865B02B8BA25387CAF16404ABF27BDB83C881",
128 "6DEBC32D2EF05EA488310529008AD195299B83CF75DB31E37A27DE3A74300C764CD4502A402D39D99963A95D80AE53CA943F05231EF80504E1B835F217B3A089",
129 "AB9088FA600829509A438BA050CCD85AFE976463717422A320025ACFEBC6169554D1CBAB8D1AC600FA08929C71D552523596714B8B920CD0E9BFAD630BA5E9B1",
130 "010001",
131 "CF9ADE648ADAC83320A9D783311954B29A85A7A1B77533B6A9AC8424B3DEDB7D852D9665E53F7295249F2868CA4FDB441C3E60128ADD26A5EBFF0B5ED48838492A6E5BBF123747BD056BBCDBF3EEE4118E41687C6113D742C880BE368FDC088B4FACA4E2760CC9636C495893EDCCAADC253B0A603F8B543AC34D31E794A444FD",
132 "F7BE5E23C3323FBF8B8E3AEEFCFCCBE5F7F10BBC4282AED57A3ECAF7D5693F6425A21FB77575059242EBB8F1F30A05E394D1557835A036A09B7C92846CDDDC4D",
133 "D6860E85420B0408842160F00E0D88FD1E3610654F1E53B40872805C3F596617E698F2E96C7A064CAC763DED8CA1CEAD1BBDB47D28BCE30E388D99D805B5A371",
134 "DCCC27C8E4DC6248D59BAFF5AB60F621FD53E2B75D09C91AA104A9FC612C5D04583A5A39F14A215667FDCC20A38F78185A793D2E8E7E860AE6A833C104174A9F" };
135
136 /*** openssl public RSA key in DER format */
137 static const unsigned char openssl_public_rsa[] = {
138 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
139 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde,
140 0x64, 0x8a, 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7,
141 0xa1, 0xb7, 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96,
142 0x65, 0xe5, 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28, 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60,
143 0x12, 0x8a, 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b, 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b,
144 0xbf, 0x12, 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc, 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68,
145 0x7c, 0x61, 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe, 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4,
146 0xe2, 0x76, 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58, 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a,
147 0x60, 0x3f, 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31, 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01,
148 0x00, 0x01, };
149
150 /* same key but with extra headers stripped */
151 static const unsigned char openssl_public_rsa_stripped[] = {
152 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde,
153 0x64, 0x8a, 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7,
154 0xa1, 0xb7, 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96,
155 0x65, 0xe5, 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28, 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60,
156 0x12, 0x8a, 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b, 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b,
157 0xbf, 0x12, 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc, 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68,
158 0x7c, 0x61, 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe, 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4,
159 0xe2, 0x76, 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58, 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a,
160 0x60, 0x3f, 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31, 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01,
161 0x00, 0x01, };
162
163
164 /* generated with the private key above as:
165 echo -n 'test' | openssl rsautl -sign -inkey rsa_private.pem -pkcs -hexdump
166 */
167 static const unsigned char openssl_rsautl_pkcs[] = {
168 0x24, 0xef, 0x54, 0xea, 0x1a, 0x12, 0x0c, 0xf4, 0x04, 0x0c, 0x48, 0xc8, 0xe8, 0x17, 0xd2, 0x6f,
169 0xc3, 0x41, 0xb3, 0x97, 0x5c, 0xbc, 0xa3, 0x2d, 0x21, 0x00, 0x10, 0x0e, 0xbb, 0xf7, 0x30, 0x21,
170 0x7e, 0x12, 0xd2, 0xdf, 0x26, 0x28, 0xd8, 0x0f, 0x6d, 0x4d, 0xc8, 0x4d, 0xa8, 0x78, 0xe7, 0x03,
171 0xee, 0xbc, 0x68, 0xba, 0x98, 0xea, 0xe9, 0xb6, 0x06, 0x8d, 0x85, 0x5b, 0xdb, 0xa6, 0x49, 0x86,
172 0x6f, 0xc7, 0x3d, 0xe0, 0x53, 0x83, 0xe0, 0xea, 0xb1, 0x08, 0x6a, 0x7b, 0xbd, 0xeb, 0xb5, 0x4a,
173 0xdd, 0xbc, 0x64, 0x97, 0x8c, 0x17, 0x20, 0xa3, 0x5c, 0xd4, 0xb8, 0x87, 0x43, 0xc5, 0x13, 0xad,
174 0x41, 0x6e, 0x45, 0x41, 0x32, 0xd4, 0x09, 0x12, 0x7f, 0xdc, 0x59, 0x1f, 0x28, 0x3f, 0x1e, 0xbc,
175 0xef, 0x57, 0x23, 0x4b, 0x3a, 0xa3, 0x24, 0x91, 0x4d, 0xfb, 0xb2, 0xd4, 0xe7, 0x5e, 0x41, 0x7e,
176 };
177
178 extern const unsigned char _der_tests_cacert_root_cert[];
179 extern const unsigned long _der_tests_cacert_root_cert_size;
180
181 static int rsa_compat_test(void)
182 {
183 rsa_key key, pubkey;
184 int stat, i;
185 unsigned char buf[1024], key_parts[8][128];
186 unsigned long len, key_lens[8];
187
188 /* try reading the key */
189 DO(rsa_import(openssl_private_rsa, sizeof(openssl_private_rsa), &key));
190 DO(rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &pubkey));
191
192 /* sign-verify a message with PKCS #1 v1.5 no ASN.1 */
193 len = sizeof(buf);
194 DO(rsa_sign_hash_ex((unsigned char*)"test", 4, buf, &len, LTC_PKCS_1_V1_5_NA1, NULL, 0, 0, 0, &key));
195 if (len != sizeof(openssl_rsautl_pkcs) || memcmp(buf, openssl_rsautl_pkcs, len)) {
196 fprintf(stderr, "RSA rsa_sign_hash_ex + LTC_PKCS_1_V1_5_NA1 failed\n");
197 return 1;
198 }
199 stat = 0;
200 DO(rsa_verify_hash_ex(openssl_rsautl_pkcs, sizeof(openssl_rsautl_pkcs), (unsigned char*)"test", 4, LTC_PKCS_1_V1_5_NA1, 0, 0, &stat, &pubkey));
201 if (stat != 1) {
202 fprintf(stderr, "RSA rsa_verify_hash_ex + LTC_PKCS_1_V1_5_NA1 failed\n");
203 return 1;
204 }
205 rsa_free(&pubkey);
206
207 /* now try to export private/public and compare */
208 len = sizeof(buf);
209 DO(rsa_export(buf, &len, PK_PRIVATE, &key));
210 if (compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from OpenSSL)", 0)) {
211 return 1;
212 }
213
214 len = sizeof(buf);
215 DO(rsa_export(buf, &len, PK_PUBLIC, &key));
216 if (compare_testvector(buf, len, openssl_public_rsa_stripped, sizeof(openssl_public_rsa_stripped), "RSA public export (from OpenSSL private key)", 0)) {
217 return 1;
218 }
219 rsa_free(&key);
220
221 /* try reading the public key */
222 DO(rsa_import(openssl_public_rsa_stripped, sizeof(openssl_public_rsa_stripped), &key));
223 len = sizeof(buf);
224 DO(rsa_export(buf, &len, PK_PUBLIC, &key));
225 if (compare_testvector(buf, len, openssl_public_rsa_stripped, sizeof(openssl_public_rsa_stripped), "RSA public export (from stripped OpenSSL)", 0)) {
226 return 1;
227 }
228 rsa_free(&key);
229
230 /* try reading the public key */
231 DO(rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &key));
232 len = sizeof(buf);
233 DO(rsa_export(buf, &len, PK_PUBLIC, &key));
234 if (compare_testvector(buf, len, openssl_public_rsa_stripped, sizeof(openssl_public_rsa_stripped), "RSA public export (from OpenSSL)", 0)) {
235 return 1;
236 }
237 rsa_free(&key);
238
239 /* try import private key in pkcs8 format */
240 DO(rsa_import_pkcs8(pkcs8_private_rsa, sizeof(pkcs8_private_rsa), NULL, 0, &key));
241 len = sizeof(buf);
242 DO(rsa_export(buf, &len, PK_PRIVATE, &key));
243 if (compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from PKCS#8)", 0)) {
244 return 1;
245 }
246 rsa_free(&key);
247
248 /* convert raw hexadecimal numbers to binary */
249 for (i = 0; i < 8; ++i) {
250 key_lens[i] = sizeof(key_parts[i]);
251 DO(radix_to_bin(hex_key[i], 16, key_parts[i], &key_lens[i]));
252 }
253 /* try import private key from converted raw hexadecimal numbers */
254 DO(rsa_set_key(key_parts[pk_N], key_lens[pk_N], key_parts[pk_e], key_lens[pk_e], key_parts[pk_d], key_lens[pk_d], &key));
255 DO(rsa_set_factors(key_parts[pk_p], key_lens[pk_p], key_parts[pk_q], key_lens[pk_q], &key));
256 DO(rsa_set_crt_params(key_parts[pk_dP], key_lens[pk_dP], key_parts[pk_dQ], key_lens[pk_dQ], key_parts[pk_qP], key_lens[pk_qP], &key));
257 len = sizeof(buf);
258 DO(rsa_export(buf, &len, PK_PRIVATE, &key));
259 if (compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from hex)", 0)) {
260 return 1;
261 }
262 rsa_free(&key);
263
264 /* try import public key from converted raw hexadecimal numbers */
265 DO(rsa_set_key(key_parts[pk_N], key_lens[pk_N], key_parts[pk_e], key_lens[pk_e], NULL, 0, &key));
266 len = sizeof(buf);
267 DO(rsa_export(buf, &len, PK_PUBLIC, &key));
268 if (compare_testvector(buf, len, openssl_public_rsa_stripped, sizeof(openssl_public_rsa_stripped), "RSA public export (from hex)", 0)) {
269 return 1;
270 }
271 rsa_free(&key);
272
273 /* try export in SubjectPublicKeyInfo format of the public key */
274 DO(rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &key));
275 len = sizeof(buf);
276 DO(rsa_export(buf, &len, PK_PUBLIC | PK_STD, &key));
277 if (len != sizeof(openssl_public_rsa) || memcmp(buf, openssl_public_rsa, len)) {
278 fprintf(stderr, "RSA(public) SSL public X.509 export failed to match OpenSSL output\n");
279 print_hex("should", openssl_public_rsa, sizeof(openssl_public_rsa));
280 print_hex("is", buf, len);
281 return 1;
282 }
283 rsa_free(&key);
284
285 return 0;
286 }
287
288 static int _rsa_key_cmp(const int should_type, const rsa_key *should, const rsa_key *is)
289 {
290 if(should_type != is->type)
291 return CRYPT_ERROR;
292 if(should_type == PK_PRIVATE) {
293 if(mp_cmp(should->q, is->q) != LTC_MP_EQ)
294 return CRYPT_ERROR;
295 if(mp_cmp(should->p, is->p) != LTC_MP_EQ)
296 return CRYPT_ERROR;
297 if(mp_cmp(should->qP, is->qP) != LTC_MP_EQ)
298 return CRYPT_ERROR;
299 if(mp_cmp(should->dP, is->dP) != LTC_MP_EQ)
300 return CRYPT_ERROR;
301 if(mp_cmp(should->dQ, is->dQ) != LTC_MP_EQ)
302 return CRYPT_ERROR;
303 if(mp_cmp(should->d, is->d) != LTC_MP_EQ)
304 return CRYPT_ERROR;
305 }
306 if(mp_cmp(should->N, is->N) != LTC_MP_EQ)
307 return CRYPT_ERROR;
308 if(mp_cmp(should->e, is->e) != LTC_MP_EQ)
309 return CRYPT_ERROR;
310 return CRYPT_OK;
311 }
312
313 static int _rsa_issue_301(int prng_idx)
314 {
315 rsa_key key, key_in;
316 unsigned char buf[4096];
317 unsigned long len;
318
319 DO(rsa_make_key(&yarrow_prng, prng_idx, sizeof(buf)/8, 65537, &key));
320
321 len = sizeof(buf);
322 DO(rsa_export(buf, &len, PK_PRIVATE, &key));
323 DO(rsa_import(buf, len, &key_in));
324
325 DO(_rsa_key_cmp(PK_PRIVATE, &key, &key_in));
326 rsa_free(&key_in);
327
328 len = sizeof(buf);
329 DO(rsa_export(buf, &len, PK_PUBLIC, &key));
330 DO(rsa_import(buf, len, &key_in));
331
332 DO(_rsa_key_cmp(PK_PUBLIC, &key, &key_in));
333 rsa_free(&key_in);
334
335 len = sizeof(buf);
336 DO(rsa_export(buf, &len, PK_PUBLIC | PK_STD, &key));
337 DO(rsa_import(buf, len, &key_in));
338
339 DO(_rsa_key_cmp(PK_PUBLIC, &key, &key_in));
340 rsa_free(&key_in);
341
342 rsa_free(&key);
343 return CRYPT_OK;
344 }
345
346 int rsa_test(void)
347 {
348 unsigned char in[1024], out[1024], tmp[3072];
349 rsa_key key, privKey, pubKey;
350 int hash_idx, prng_idx, stat, stat2, i, err;
351 unsigned long rsa_msgsize, len, len2, len3, cnt, cnt2;
352 static unsigned char lparam[] = { 0x01, 0x02, 0x03, 0x04 };
353 void* dP;
354 unsigned char* p;
355 unsigned char* p2;
356 unsigned char* p3;
357
358 if (rsa_compat_test() != 0) {
359 return 1;
360 }
361
362 hash_idx = find_hash("sha1");
363 prng_idx = find_prng("yarrow");
364 if (hash_idx == -1 || prng_idx == -1) {
365 fprintf(stderr, "rsa_test requires LTC_SHA1 and yarrow");
366 return 1;
367 }
368
369 DO(_rsa_issue_301(prng_idx));
370
371 /* make 10 random key */
372 for (cnt = 0; cnt < 10; cnt++) {
373 DO(rsa_make_key(&yarrow_prng, prng_idx, 1024/8, 65537, &key));
374 if (mp_count_bits(key.N) != 1024) {
375 fprintf(stderr, "rsa_1024 key modulus has %d bits\n", mp_count_bits(key.N));
376
377 len = mp_unsigned_bin_size(key.N);
378 mp_to_unsigned_bin(key.N, tmp);
379 print_hex("N", tmp, len);
380
381 len = mp_unsigned_bin_size(key.p);
382 mp_to_unsigned_bin(key.p, tmp);
383 print_hex("p", tmp, len);
384
385 len = mp_unsigned_bin_size(key.q);
386 mp_to_unsigned_bin(key.q, tmp);
387 print_hex("q", tmp, len);
388
389 return 1;
390 }
391 if (cnt != 9) {
392 rsa_free(&key);
393 }
394 }
395
396 /* encrypt the key (without lparam) */
397 for (cnt = 0; cnt < 4; cnt++) {
398 for (rsa_msgsize = 1; rsa_msgsize <= 86; rsa_msgsize++) {
399 /* make a random key/msg */
400 yarrow_read(in, rsa_msgsize, &yarrow_prng);
401
402 len = sizeof(out);
403 len2 = rsa_msgsize;
404
405 DO(rsa_encrypt_key(in, rsa_msgsize, out, &len, NULL, 0, &yarrow_prng, prng_idx, hash_idx, &key));
406 /* change a byte */
407 out[8] ^= 1;
408 DOX((err = rsa_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat2, &key))
409 == CRYPT_INVALID_PACKET ? CRYPT_OK:err, "should fail");
410 /* change a byte back */
411 out[8] ^= 1;
412 if (len2 != rsa_msgsize) {
413 fprintf(stderr, "\n%i:rsa_decrypt_key mismatch len %lu (first decrypt)", __LINE__, len2);
414 return 1;
415 }
416
417 len2 = rsa_msgsize;
418 DO(rsa_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat, &key));
419 if (!(stat == 1 && stat2 == 0)) {
420 fprintf(stderr, "rsa_decrypt_key (without lparam) failed (rsa_msgsize = %lu)", rsa_msgsize);
421 fprintf(stderr, "\n stat: %i stat2: %i", stat, stat2);
422 return 1;
423 }
424 if (len2 != rsa_msgsize || memcmp(tmp, in, rsa_msgsize)) {
425 fprintf(stderr, "\nrsa_decrypt_key mismatch, len %lu (second decrypt)\n", len2);
426 print_hex("Original", in, rsa_msgsize);
427 print_hex("Output", tmp, len2);
428 return 1;
429 }
430 }
431 }
432
433 /* encrypt the key (with lparam) */
434 for (rsa_msgsize = 1; rsa_msgsize <= 86; rsa_msgsize++) {
435 len = sizeof(out);
436 len2 = rsa_msgsize;
437 DO(rsa_encrypt_key(in, rsa_msgsize, out, &len, lparam, sizeof(lparam), &yarrow_prng, prng_idx, hash_idx, &key));
438 /* change a byte */
439 out[8] ^= 1;
440 DOX((err = rsa_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat2, &key))
441 == CRYPT_INVALID_PACKET ? CRYPT_OK:err, "should fail");
442 if (len2 != rsa_msgsize) {
443 fprintf(stderr, "\n%i:rsa_decrypt_key mismatch len %lu (first decrypt)", __LINE__, len2);
444 return 1;
445 }
446 /* change a byte back */
447 out[8] ^= 1;
448
449 len2 = rsa_msgsize;
450 DO(rsa_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat, &key));
451 if (!(stat == 1 && stat2 == 0)) {
452 fprintf(stderr, "rsa_decrypt_key (with lparam) failed (rsa_msgsize = %lu)", rsa_msgsize);
453 return 1;
454 }
455 if (len2 != rsa_msgsize || memcmp(tmp, in, rsa_msgsize)) {
456 fprintf(stderr, "rsa_decrypt_key mismatch len %lu", len2);
457 print_hex("Original", in, rsa_msgsize);
458 print_hex("Output", tmp, len2);
459 return 1;
460 }
461 }
462
463 /* encrypt the key PKCS #1 v1.5 (payload from 1 to 117 bytes) */
464 for (rsa_msgsize = 1; rsa_msgsize <= 117; rsa_msgsize++) {
465 len = sizeof(out);
466 len2 = rsa_msgsize;
467 /* make a random key/msg */
468 yarrow_read(in, rsa_msgsize, &yarrow_prng);
469 DO(rsa_encrypt_key_ex(in, rsa_msgsize, out, &len, NULL, 0, &yarrow_prng, prng_idx, 0, LTC_PKCS_1_V1_5, &key));
470
471 len2 = rsa_msgsize;
472 DO(rsa_decrypt_key_ex(out, len, tmp, &len2, NULL, 0, 0, LTC_PKCS_1_V1_5, &stat, &key));
473 if (stat != 1) {
474 fprintf(stderr, "rsa_decrypt_key_ex failed, %d, %d", stat, stat2);
475 return 1;
476 }
477 if (len2 != rsa_msgsize) {
478 fprintf(stderr, "rsa_decrypt_key_ex mismatch len %lu", len2);
479 return 1;
480 }
481 if (memcmp(tmp, in, rsa_msgsize)) {
482 fprintf(stderr, "rsa_decrypt_key_ex mismatch data");
483 print_hex("Original", in, rsa_msgsize);
484 print_hex("Output", tmp, rsa_msgsize);
485 return 1;
486 }
487 }
488
489 /* sign a message (unsalted, lower cholestorol and Atkins approved) now */
490 len = sizeof(out);
491 DO(rsa_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 0, &key));
492
493 /* export key and import as both private and public */
494 len2 = sizeof(tmp);
495 DO(rsa_export(tmp, &len2, PK_PRIVATE, &key));
496 DO(rsa_import(tmp, len2, &privKey));
497 len2 = sizeof(tmp);
498 DO(rsa_export(tmp, &len2, PK_PUBLIC, &key));
499 DO(rsa_import(tmp, len2, &pubKey));
500
501 /* verify with original */
502 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &key));
503 /* change a byte */
504 in[0] ^= 1;
505 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &key));
506
507 if (!(stat == 1 && stat2 == 0)) {
508 fprintf(stderr, "rsa_verify_hash (unsalted, origKey) failed, %d, %d", stat, stat2);
509 rsa_free(&key);
510 rsa_free(&pubKey);
511 rsa_free(&privKey);
512 return 1;
513 }
514
515 /* verify with privKey */
516 /* change byte back to original */
517 in[0] ^= 1;
518 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &privKey));
519 /* change a byte */
520 in[0] ^= 1;
521 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &privKey));
522
523 if (!(stat == 1 && stat2 == 0)) {
524 fprintf(stderr, "rsa_verify_hash (unsalted, privKey) failed, %d, %d", stat, stat2);
525 rsa_free(&key);
526 rsa_free(&pubKey);
527 rsa_free(&privKey);
528 return 1;
529 }
530
531 /* verify with privKey but remove pointer to dP to test without CRT */
532
533 dP = privKey.dP;
534 privKey.dP = NULL;
535 /* change byte back to original */
536 in[0] ^= 1;
537 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &privKey));
538 /* change a byte */
539 in[0] ^= 1;
540 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &privKey));
541
542 if (!(stat == 1 && stat2 == 0)) {
543 fprintf(stderr, "rsa_verify_hash (unsalted, privKey) failed, %d, %d", stat, stat2);
544 rsa_free(&key);
545 rsa_free(&pubKey);
546 rsa_free(&privKey);
547 return 1;
548 }
549 privKey.dP = dP;
550
551 /* verify with pubKey */
552 /* change byte back to original */
553 in[0] ^= 1;
554 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &pubKey));
555 /* change a byte */
556 in[0] ^= 1;
557 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &pubKey));
558
559 if (!(stat == 1 && stat2 == 0)) {
560 fprintf(stderr, "rsa_verify_hash (unsalted, pubkey) failed, %d, %d", stat, stat2);
561 rsa_free(&key);
562 rsa_free(&pubKey);
563 rsa_free(&privKey);
564 return 1;
565 }
566
567 /* sign a message (salted) now (use privKey to make, pubKey to verify) */
568 len = sizeof(out);
569 DO(rsa_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 8, &privKey));
570 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 8, &stat, &pubKey));
571 /* change a byte */
572 in[0] ^= 1;
573 DO(rsa_verify_hash(out, len, in, 20, hash_idx, 8, &stat2, &pubKey));
574
575 if (!(stat == 1 && stat2 == 0)) {
576 fprintf(stderr, "rsa_verify_hash (salted) failed, %d, %d", stat, stat2);
577 rsa_free(&key);
578 rsa_free(&pubKey);
579 rsa_free(&privKey);
580 return 1;
581 }
582
583 /* sign a message with PKCS #1 v1.5 */
584 len = sizeof(out);
585 DO(rsa_sign_hash_ex(in, 20, out, &len, LTC_PKCS_1_V1_5, &yarrow_prng, prng_idx, hash_idx, 8, &privKey));
586 DO(rsa_verify_hash_ex(out, len, in, 20, LTC_PKCS_1_V1_5, hash_idx, 8, &stat, &pubKey));
587 /* change a byte */
588 in[0] ^= 1;
589 DO(rsa_verify_hash_ex(out, len, in, 20, LTC_PKCS_1_V1_5, hash_idx, 8, &stat2, &pubKey));
590
591 if (!(stat == 1 && stat2 == 0)) {
592 fprintf(stderr, "rsa_verify_hash_ex failed, %d, %d", stat, stat2);
593 rsa_free(&key);
594 rsa_free(&pubKey);
595 rsa_free(&privKey);
596 return 1;
597 }
598
599 /* Testcase for Bleichenbacher attack
600 *
601 * (1) Create a valid signature
602 * (2) Check that it can be verified
603 * (3) Decrypt the package to fetch plain text
604 * (4) Forge the structure of PKCS#1-EMSA encoded data
605 * (4.1) Search for start and end of the padding string
606 * (4.2) Move the signature to the front of the padding string
607 * (4.3) Zero the message until the end
608 * (5) Encrypt the package again
609 * (6) Profit :)
610 * For PS lengths < 8: the verification process should fail
611 * For PS lengths >= 8: the verification process should succeed
612 * For all PS lengths: the result should not be valid
613 */
614
615 p = in;
616 p2 = out;
617 p3 = tmp;
618 for (i = 0; i < 9; ++i) {
619 len = sizeof(in);
620 len2 = sizeof(out);
621 /* (1) */
622 DO(rsa_sign_hash_ex(p, 20, p2, &len2, LTC_PKCS_1_V1_5, &yarrow_prng, prng_idx, hash_idx, 8, &privKey));
623 /* (2) */
624 DOX(rsa_verify_hash_ex(p2, len2, p, 20, LTC_PKCS_1_V1_5, hash_idx, -1, &stat, &pubKey), "should succeed");
625 DOX(stat == 1?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, "should succeed");
626 len3 = sizeof(tmp);
627 /* (3) */
628 DO(ltc_mp.rsa_me(p2, len2, p3, &len3, PK_PUBLIC, &key));
629 /* (4) */
630 #if defined(LTC_TEST_DBG) && LTC_TEST_DBG > 1
631 print_hex("Original signature", p3, len3);
632 #endif
633 /* (4.1) */
634 for (cnt = 0; cnt < len3; ++cnt) {
635 if (p3[cnt] == 0xff)
636 break;
637 }
638 for (cnt2 = cnt+1; cnt2 < len3; ++cnt2) {
639 if (p3[cnt2] != 0xff)
640 break;
641 }
642 /* (4.2) */
643 memmove(&p3[cnt+i], &p3[cnt2], len3-cnt2);
644 /* (4.3) */
645 for (cnt = cnt + len3-cnt2+i; cnt < len; ++cnt) {
646 p3[cnt] = 0;
647 }
648 #if defined(LTC_TEST_DBG) && LTC_TEST_DBG > 1
649 print_hex("Forged signature", p3, len3);
650 #endif
651
652 len2 = sizeof(out);
653 /* (5) */
654 DO(ltc_mp.rsa_me(p3, len3, p2, &len2, PK_PRIVATE, &key));
655
656 len3 = sizeof(tmp);
657 /* (6) */
658 if (i < 8)
659 DOX(rsa_verify_hash_ex(p2, len2, p, 20, LTC_PKCS_1_V1_5, hash_idx, -1, &stat, &pubKey)
660 == CRYPT_INVALID_PACKET ? CRYPT_OK:CRYPT_INVALID_PACKET, "should fail");
661 else
662 DOX(rsa_verify_hash_ex(p2, len2, p, 20, LTC_PKCS_1_V1_5, hash_idx, -1, &stat, &pubKey), "should succeed");
663 DOX(stat == 0?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, "should fail");
664 }
665 rsa_free(&key);
666
667 /* try reading the public RSA key from a X509 certificate */
668 len3 = sizeof(tmp);
669 DO(base64_decode(x509_public_rsa, sizeof(x509_public_rsa), tmp, &len3));
670 DO(rsa_import_x509(tmp, len3, &key));
671 len = sizeof(tmp);
672 DO(rsa_export(tmp, &len, PK_PUBLIC, &key));
673 if (len != sizeof(openssl_public_rsa_stripped) || memcmp(tmp, openssl_public_rsa_stripped, len)) {
674 fprintf(stderr, "RSA public export failed to match rsa_import_x509\n");
675 return 1;
676 }
677 rsa_free(&key);
678
679 len3 = sizeof(tmp);
680 DO(base64_decode(_der_tests_cacert_root_cert, _der_tests_cacert_root_cert_size, tmp, &len3));
681
682 DO(rsa_import_x509(tmp, len3, &key));
683
684 /* free the key and return */
685 rsa_free(&key);
686 rsa_free(&pubKey);
687 rsa_free(&privKey);
688 return 0;
689 }
690
691 #else
692
693 int rsa_test(void)
694 {
695 return CRYPT_NOP;
696 }
697
698 #endif
699
700 /* ref: $Format:%D$ */
701 /* git commit: $Format:%H$ */
702 /* commit time: $Format:%ai$ */