test_cert.c (12185B)
1 #include <check.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 #include "lq/msg.h" 6 #include "lq/cert.h" 7 #include "lq/mem.h" 8 #include "lq/crypto.h" 9 #include "lq/config.h" 10 #include "lq/base.h" 11 #include "lq/io.h" 12 13 const char *data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."; 14 const char *data_two = "Que trata de la condición y ejercicio del famoso hidalgo D. Quijote de la Mancha En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor."; 15 16 //// sha256sum "foo" 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae 17 //static const char privkeydata[32] = { 18 // 0x2c, 0x26, 0xb4, 0x6b, 0x68, 0xff, 0xc6, 0x8f, 19 // 0xf9, 0x9b, 0x45, 0x3c, 0x1d, 0x30, 0x41, 0x34, 20 // 0x13, 0x42, 0x2d, 0x70, 0x64, 0x83, 0xbf, 0xa0, 21 // 0xf9, 0x8a, 0x5e, 0x88, 0x62, 0x66, 0xe7, 0xae, 22 //}; 23 24 // sha256sum "bar" fcde2b2edba56bf408601fb721fe9b5c338d10ee429ea04fae5511b68fbf8fb9 25 static const char passphrase[32] = { 26 0xfc, 0xde, 0x2b, 0x2e, 0xdb, 0xa5, 0x6b, 0xf4, 27 0x08, 0x60, 0x1f, 0xb7, 0x21, 0xfe, 0x9b, 0x5c, 28 0x33, 0x8d, 0x10, 0xee, 0x42, 0x9e, 0xa0, 0x4f, 29 0xae, 0x55, 0x11, 0xb6, 0x8f, 0xbf, 0x8f, 0xb9, 30 }; 31 32 33 START_TEST(check_cert_sig_req) { 34 int r; 35 LQCert *cert; 36 LQMsg *req; 37 LQPrivKey *pk; 38 39 pk = lq_privatekey_new(passphrase, sizeof(passphrase)); 40 ck_assert_ptr_nonnull(pk); 41 r = lq_privatekey_unlock(pk, passphrase, sizeof(passphrase)); 42 ck_assert_int_eq(r, 0); 43 44 cert = lq_certificate_new(NULL); 45 ck_assert_ptr_nonnull(cert); 46 47 req = lq_msg_new("foo", 4); 48 ck_assert_ptr_nonnull(req); 49 r = lq_certificate_request(cert, req, pk); 50 ck_assert_int_eq(r, 0); 51 52 r = lq_certificate_verify(cert, NULL, NULL); 53 ck_assert_int_eq(r, 0); 54 55 lq_certificate_free(cert); 56 lq_privatekey_free(pk); 57 } 58 END_TEST 59 60 START_TEST(check_cert_sig_res) { 61 int r; 62 LQCert *cert; 63 LQMsg *req; 64 LQMsg *res; 65 LQPrivKey *pk_alice; 66 LQPrivKey *pk_bob; 67 68 pk_alice = lq_privatekey_new(passphrase, LQ_PRIVKEY_LEN); 69 ck_assert_ptr_nonnull(pk_alice); 70 r = lq_privatekey_unlock(pk_alice, passphrase, sizeof(passphrase)); 71 ck_assert_int_eq(r, 0); 72 73 pk_bob = lq_privatekey_new(passphrase, LQ_PRIVKEY_LEN); 74 ck_assert_ptr_nonnull(pk_bob); 75 r = lq_privatekey_unlock(pk_bob, passphrase, sizeof(passphrase)); 76 ck_assert_int_eq(r, 0); 77 78 cert = lq_certificate_new(NULL); 79 ck_assert_ptr_nonnull(cert); 80 81 req = lq_msg_new("foo", 4); 82 ck_assert_ptr_nonnull(req); 83 r = lq_certificate_request(cert, req, pk_alice); 84 ck_assert_int_eq(r, 0); 85 86 res = lq_msg_new("barbaz", 7); 87 ck_assert_ptr_nonnull(res); 88 r = lq_certificate_respond(cert, res, pk_bob); 89 ck_assert_int_eq(r, 0); 90 91 r = lq_certificate_verify(cert, NULL, NULL); 92 ck_assert_int_eq(r, 0); 93 94 lq_certificate_free(cert); 95 lq_privatekey_free(pk_bob); 96 lq_privatekey_free(pk_alice); 97 } 98 END_TEST 99 100 START_TEST(check_cert_symmetric_ser_nomsg) { 101 int r; 102 size_t c; 103 LQCert *cert; 104 char buf[LQ_BLOCKSIZE]; 105 106 cert = lq_certificate_new(NULL); 107 ck_assert_ptr_nonnull(cert); 108 c = LQ_BLOCKSIZE; 109 r = lq_certificate_serialize(cert, NULL, buf, &c); 110 ck_assert_int_eq(r, 0); 111 lq_certificate_free(cert); 112 113 cert = lq_certificate_new(NULL); 114 ck_assert_ptr_nonnull(cert); 115 r = lq_certificate_deserialize(&cert, NULL, buf, c); 116 ck_assert_int_eq(r, 0); 117 lq_certificate_free(cert); 118 } 119 END_TEST 120 121 START_TEST(check_cert_symmetric_ser_req_nosig) { 122 int r; 123 size_t c; 124 LQCert *cert; 125 LQMsg *req; 126 char buf[4096]; 127 128 req = lq_msg_new(data, strlen(data) + 1); 129 ck_assert_ptr_nonnull(req); 130 131 cert = lq_certificate_new(NULL); 132 ck_assert_ptr_nonnull(cert); 133 134 r = lq_certificate_request(cert, req, NULL); 135 c = LQ_BLOCKSIZE; 136 r = lq_certificate_serialize(cert, NULL, buf, &c); 137 ck_assert_int_eq(r, 0); 138 lq_certificate_free(cert); 139 140 cert = lq_certificate_new(NULL); 141 ck_assert_ptr_nonnull(cert); 142 r = lq_certificate_deserialize(&cert, NULL, buf, c); 143 ck_assert_int_eq(r, 0); 144 lq_certificate_free(cert); 145 } 146 END_TEST 147 148 START_TEST(check_cert_symmetric_ser_req_sig) { 149 int r; 150 size_t c; 151 LQCert *cert; 152 LQMsg *req; 153 LQPrivKey *pk; 154 char buf[4096]; 155 156 pk = lq_privatekey_new(passphrase, sizeof(passphrase)); 157 ck_assert_ptr_nonnull(pk); 158 159 r = lq_privatekey_unlock(pk, passphrase, sizeof(passphrase)); 160 ck_assert_int_eq(r, 0); 161 162 req = lq_msg_new(data, strlen(data) + 1); 163 ck_assert_ptr_nonnull(req); 164 165 cert = lq_certificate_new(NULL); 166 ck_assert_ptr_nonnull(cert); 167 r = lq_certificate_request(cert, req, pk); 168 ck_assert_int_eq(r, 0); 169 170 c = LQ_BLOCKSIZE; 171 r = lq_certificate_serialize(cert, NULL, buf, &c); 172 ck_assert_int_eq(r, 0); 173 lq_certificate_free(cert); 174 175 r = lq_certificate_deserialize(&cert, NULL , buf, c); 176 ck_assert_int_eq(r, 0); 177 178 lq_certificate_free(cert); 179 lq_privatekey_free(pk); 180 } 181 END_TEST 182 183 START_TEST(check_cert_symmetric_ser_rsp_onesig) { 184 int r; 185 size_t c; 186 LQCert *cert; 187 LQMsg *req; 188 LQMsg *res; 189 LQPrivKey *pk; 190 char buf[4096]; 191 192 pk = lq_privatekey_new(passphrase, sizeof(passphrase)); 193 ck_assert_ptr_nonnull(pk); 194 req = lq_msg_new(data, strlen(data) + 1); 195 ck_assert_ptr_nonnull(req); 196 res = lq_msg_new(data_two, strlen(data_two) + 1); 197 ck_assert_ptr_nonnull(res); 198 199 cert = lq_certificate_new(NULL); 200 lq_privatekey_unlock(pk, passphrase, sizeof(passphrase)); 201 r = lq_certificate_request(cert, req, pk); 202 ck_assert_int_eq(r, 0); 203 204 c = LQ_BLOCKSIZE; 205 r = lq_certificate_serialize(cert, NULL, buf, &c); 206 ck_assert_int_eq(r, 0); 207 lq_certificate_free(cert); 208 209 r = lq_certificate_deserialize(&cert, NULL, buf, c); 210 ck_assert_int_eq(r, 0); 211 212 r = lq_certificate_respond(cert, res, pk); 213 ck_assert_int_eq(r, 0); 214 215 lq_certificate_free(cert); 216 lq_privatekey_free(pk); 217 } 218 END_TEST 219 220 START_TEST(check_cert_symmetric_ser_rsp_bothsig) { 221 int r; 222 size_t c; 223 LQCert *cert; 224 LQMsg *req; 225 LQMsg *res; 226 LQPrivKey *pk_alice; 227 LQPrivKey *pk_bob; 228 char buf[LQ_BLOCKSIZE]; 229 230 pk_alice = lq_privatekey_new(passphrase, sizeof(passphrase)); 231 ck_assert_ptr_nonnull(pk_alice); 232 pk_bob = lq_privatekey_new(passphrase, sizeof(passphrase)); 233 ck_assert_ptr_nonnull(pk_bob); 234 r = lq_privatekey_unlock(pk_alice, passphrase, sizeof(passphrase)); 235 ck_assert_int_eq(r, 0); 236 r = lq_privatekey_unlock(pk_bob, passphrase, sizeof(passphrase)); 237 ck_assert_int_eq(r, 0); 238 cert = lq_certificate_new(NULL); 239 ck_assert_ptr_nonnull(cert); 240 241 req = lq_msg_new(data, strlen(data) + 1); 242 ck_assert_ptr_nonnull(req); 243 r = lq_certificate_request(cert, req, pk_alice); 244 ck_assert_int_eq(r, 0); 245 246 res = lq_msg_new(data_two, strlen(data_two) + 1); 247 ck_assert_ptr_nonnull(res); 248 r = lq_certificate_respond(cert, res, pk_bob); 249 ck_assert_int_eq(r, 0); 250 251 c = LQ_BLOCKSIZE; 252 r = lq_certificate_serialize(cert, NULL, buf, &c); 253 ck_assert_int_eq(r, 0); 254 lq_certificate_free(cert); 255 256 r = lq_certificate_deserialize(&cert, NULL, buf, c); 257 ck_assert_int_eq(r, 0); 258 lq_certificate_free(cert); 259 } 260 END_TEST 261 262 START_TEST(check_cert_verify_deserialize_literal) { 263 int r; 264 size_t c; 265 LQCert *cert; 266 LQMsg *req; 267 LQMsg *res; 268 LQPrivKey *pk_alice; 269 LQPrivKey *pk_bob; 270 char buf[LQ_BLOCKSIZE]; 271 272 pk_alice = lq_privatekey_new(passphrase, sizeof(passphrase)); 273 ck_assert_ptr_nonnull(pk_alice); 274 pk_bob = lq_privatekey_new(passphrase, sizeof(passphrase)); 275 ck_assert_ptr_nonnull(pk_bob); 276 r = lq_privatekey_unlock(pk_alice, passphrase, sizeof(passphrase)); 277 ck_assert_int_eq(r, 0); 278 r = lq_privatekey_unlock(pk_bob, passphrase, sizeof(passphrase)); 279 ck_assert_int_eq(r, 0); 280 cert = lq_certificate_new(NULL); 281 ck_assert_ptr_nonnull(cert); 282 283 req = lq_msg_new(data, strlen(data) + 1); 284 ck_assert_ptr_nonnull(req); 285 lq_msg_literal(req); 286 r = lq_certificate_request(cert, req, pk_alice); 287 ck_assert_int_eq(r, 0); 288 289 res = lq_msg_new(data_two, strlen(data_two) + 1); 290 ck_assert_ptr_nonnull(res); 291 lq_msg_literal(res); 292 r = lq_certificate_respond(cert, res, pk_bob); 293 ck_assert_int_eq(r, 0); 294 295 c = LQ_BLOCKSIZE; 296 r = lq_certificate_serialize(cert, NULL, buf, &c); 297 ck_assert_int_eq(r, 0); 298 lq_certificate_free(cert); 299 300 r = lq_certificate_deserialize(&cert, NULL, buf, c); 301 ck_assert_int_eq(r, 0); 302 303 r = lq_certificate_verify(cert, NULL, NULL); 304 ck_assert_int_eq(r, 0); 305 306 lq_certificate_free(cert); 307 } 308 END_TEST 309 310 START_TEST(check_cert_verify_deserialize_literal_with_publickeys) { 311 int r; 312 size_t c; 313 LQCert *cert; 314 LQMsg *req; 315 LQMsg *res; 316 LQPrivKey *pk_alice; 317 LQPrivKey *pk_bob; 318 LQPubKey *pubk_alice; 319 LQPubKey *pubk_bob; 320 LQPubKey *pubk_request; 321 LQPubKey *pubk_response; 322 char buf[LQ_BLOCKSIZE]; 323 324 pk_alice = lq_privatekey_new(passphrase, sizeof(passphrase)); 325 ck_assert_ptr_nonnull(pk_alice); 326 pk_bob = lq_privatekey_new(passphrase, sizeof(passphrase)); 327 ck_assert_ptr_nonnull(pk_bob); 328 r = lq_privatekey_unlock(pk_alice, passphrase, sizeof(passphrase)); 329 ck_assert_int_eq(r, 0); 330 r = lq_privatekey_unlock(pk_bob, passphrase, sizeof(passphrase)); 331 ck_assert_int_eq(r, 0); 332 cert = lq_certificate_new(NULL); 333 ck_assert_ptr_nonnull(cert); 334 335 req = lq_msg_new(data, strlen(data) + 1); 336 ck_assert_ptr_nonnull(req); 337 lq_msg_literal(req); 338 r = lq_certificate_request(cert, req, pk_alice); 339 ck_assert_int_eq(r, 0); 340 341 res = lq_msg_new(data_two, strlen(data_two) + 1); 342 ck_assert_ptr_nonnull(res); 343 lq_msg_literal(res); 344 r = lq_certificate_respond(cert, res, pk_bob); 345 ck_assert_int_eq(r, 0); 346 347 c = LQ_BLOCKSIZE; 348 r = lq_certificate_serialize(cert, NULL, buf, &c); 349 ck_assert_int_eq(r, 0); 350 lq_certificate_free(cert); 351 352 r = lq_certificate_deserialize(&cert, NULL, buf, c); 353 ck_assert_int_eq(r, 0); 354 355 pubk_alice = lq_publickey_from_privatekey(pk_alice); 356 ck_assert_ptr_nonnull(pubk_alice); 357 pubk_bob = lq_publickey_from_privatekey(pk_bob); 358 ck_assert_ptr_nonnull(pubk_bob); 359 360 r = lq_certificate_verify(cert, &pubk_request, NULL); 361 ck_assert_int_eq(r, 0); 362 r = lq_publickey_match(pubk_alice, pubk_request); 363 ck_assert_int_eq(r, 0); 364 365 r = lq_certificate_verify(cert, NULL, &pubk_response); 366 ck_assert_int_eq(r, 0); 367 r = lq_publickey_match(pubk_bob, pubk_response); 368 ck_assert_int_eq(r, 0); 369 370 r = lq_certificate_verify(cert, &pubk_request, &pubk_response); 371 ck_assert_int_eq(r, 0); 372 r = lq_publickey_match(pubk_alice, pubk_request); 373 ck_assert_int_eq(r, 0); 374 r = lq_publickey_match(pubk_bob, pubk_response); 375 ck_assert_int_eq(r, 0); 376 377 lq_publickey_free(pubk_bob); 378 lq_publickey_free(pubk_alice); 379 lq_certificate_free(cert); 380 381 } 382 END_TEST 383 // 384 //START_TEST(check_cert_attach) { 385 // int r; 386 // size_t c; 387 // size_t l; 388 // LQCert *cert; 389 // char buf[LQ_BLOCKSIZE]; 390 // char *p; 391 // 392 // cert = lq_certificate_new(NULL); 393 // ck_assert_ptr_nonnull(cert); 394 // c = LQ_BLOCKSIZE; 395 // r = lq_certificate_serialize(cert, NULL, buf, &c); 396 // ck_assert_int_eq(r, 0); 397 // lq_certificate_free(cert); 398 // 399 // r = lq_certificate_deserialize(&cert, NULL, buf, l); 400 // ck_assert_int_eq(r, 0); 401 // lq_certificate_free(cert); 402 //} 403 //END_TEST 404 405 406 407 Suite * common_suite(void) { 408 Suite *s; 409 TCase *tc; 410 411 s = suite_create("cert"); 412 tc = tcase_create("sign"); 413 tcase_add_test(tc, check_cert_sig_req); 414 tcase_add_test(tc, check_cert_sig_res); 415 suite_add_tcase(s, tc); 416 417 tc = tcase_create("serialize"); 418 tcase_add_test(tc, check_cert_symmetric_ser_nomsg); 419 tcase_add_test(tc, check_cert_symmetric_ser_req_nosig); 420 tcase_add_test(tc, check_cert_symmetric_ser_req_sig); 421 tcase_add_test(tc, check_cert_symmetric_ser_rsp_onesig); 422 tcase_add_test(tc, check_cert_symmetric_ser_rsp_bothsig); 423 tcase_add_test(tc, check_cert_verify_deserialize_literal); 424 tcase_add_test(tc, check_cert_verify_deserialize_literal_with_publickeys); 425 // tcase_add_test(tc, check_cert_attach); 426 suite_add_tcase(s, tc); 427 428 return s; 429 } 430 431 int main(void) { 432 int r; 433 int n_fail; 434 char path[LQ_PATH_MAX]; 435 436 Suite *s; 437 SRunner *sr; 438 439 r = lq_init(); 440 if (r) { 441 return 1; 442 } 443 444 lq_cpy(path, "/tmp/lqcrypto_test_XXXXXX", 26); 445 r = lq_crypto_init(mktempdir(path)); 446 if (r) { 447 return 1; 448 } 449 450 s = common_suite(); 451 sr = srunner_create(s); 452 453 srunner_run_all(sr, CK_VERBOSE); 454 n_fail = srunner_ntests_failed(sr); 455 srunner_free(sr); 456 457 return (n_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; 458 }