aboutsummaryrefslogtreecommitdiff
path: root/src/daemon/https/x509/x509_privkey.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/daemon/https/x509/x509_privkey.c')
-rw-r--r--src/daemon/https/x509/x509_privkey.c544
1 files changed, 0 insertions, 544 deletions
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
index df4e0faa..b935c3f8 100644
--- a/src/daemon/https/x509/x509_privkey.c
+++ b/src/daemon/https/x509/x509_privkey.c
@@ -32,13 +32,9 @@
32#include <gnutls_x509.h> 32#include <gnutls_x509.h>
33#include <x509_b64.h> 33#include <x509_b64.h>
34#include <x509.h> 34#include <x509.h>
35#include <dn.h>
36#include <mpi.h> 35#include <mpi.h>
37#include <extensions.h> 36#include <extensions.h>
38 37
39static int MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params);
40int MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
41
42/* remove this when libgcrypt can handle the PKCS #1 coefficients from 38/* remove this when libgcrypt can handle the PKCS #1 coefficients from
43 * rsa keys 39 * rsa keys
44 */ 40 */
@@ -92,54 +88,6 @@ MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key)
92 MHD_gnutls_free (key); 88 MHD_gnutls_free (key);
93} 89}
94 90
95/**
96 * MHD_gnutls_x509_privkey_cpy - This function copies a private key
97 * @dst: The destination key, which should be initialized.
98 * @src: The source key
99 *
100 * This function will copy a private key from source to destination key.
101 *
102 **/
103int
104MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst,
105 MHD_gnutls_x509_privkey_t src)
106{
107 int i, ret;
108
109 if (!src || !dst)
110 return GNUTLS_E_INVALID_REQUEST;
111
112 for (i = 0; i < src->params_size; i++)
113 {
114 dst->params[i] = MHD__gnutls_mpi_copy (src->params[i]);
115 if (dst->params[i] == NULL)
116 return GNUTLS_E_MEMORY_ERROR;
117 }
118
119 dst->params_size = src->params_size;
120 dst->pk_algorithm = src->pk_algorithm;
121 dst->crippled = src->crippled;
122
123 if (!src->crippled)
124 {
125 switch (dst->pk_algorithm)
126 {
127 case MHD_GNUTLS_PK_RSA:
128 ret = MHD__gnutls_asn1_encode_rsa (&dst->key, dst->params);
129 if (ret < 0)
130 {
131 MHD_gnutls_assert ();
132 return ret;
133 }
134 break;
135 default:
136 MHD_gnutls_assert ();
137 return GNUTLS_E_INVALID_REQUEST;
138 }
139 }
140
141 return 0;
142}
143 91
144/* Converts an RSA PKCS#1 key to 92/* Converts an RSA PKCS#1 key to
145 * an internal structure (MHD_gnutls_private_key) 93 * an internal structure (MHD_gnutls_private_key)
@@ -340,495 +288,3 @@ MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
340 return 0; 288 return 0;
341} 289}
342 290
343#define FREE_RSA_PRIVATE_PARAMS for (i=0;i<RSA_PRIVATE_PARAMS;i++) \
344 MHD_gtls_mpi_release(&key->params[i])
345#define FREE_DSA_PRIVATE_PARAMS for (i=0;i<DSA_PRIVATE_PARAMS;i++) \
346 MHD_gtls_mpi_release(&key->params[i])
347
348/**
349 * MHD_gnutls_x509_privkey_import_rsa_raw - This function will import a raw RSA key
350 * @key: The structure to store the parsed key
351 * @m: holds the modulus
352 * @e: holds the public exponent
353 * @d: holds the private exponent
354 * @p: holds the first prime (p)
355 * @q: holds the second prime (q)
356 * @u: holds the coefficient
357 *
358 * This function will convert the given RSA raw parameters
359 * to the native MHD_gnutls_x509_privkey_t format. The output will be stored in @key.
360 *
361 **/
362int
363MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
364 const MHD_gnutls_datum_t * m,
365 const MHD_gnutls_datum_t * e,
366 const MHD_gnutls_datum_t * d,
367 const MHD_gnutls_datum_t * p,
368 const MHD_gnutls_datum_t * q,
369 const MHD_gnutls_datum_t * u)
370{
371 int i = 0, ret;
372 size_t siz = 0;
373
374 if (key == NULL)
375 {
376 MHD_gnutls_assert ();
377 return GNUTLS_E_INVALID_REQUEST;
378 }
379
380 siz = m->size;
381 if (MHD_gtls_mpi_scan_nz (&key->params[0], m->data, &siz))
382 {
383 MHD_gnutls_assert ();
384 FREE_RSA_PRIVATE_PARAMS;
385 return GNUTLS_E_MPI_SCAN_FAILED;
386 }
387
388 siz = e->size;
389 if (MHD_gtls_mpi_scan_nz (&key->params[1], e->data, &siz))
390 {
391 MHD_gnutls_assert ();
392 FREE_RSA_PRIVATE_PARAMS;
393 return GNUTLS_E_MPI_SCAN_FAILED;
394 }
395
396 siz = d->size;
397 if (MHD_gtls_mpi_scan_nz (&key->params[2], d->data, &siz))
398 {
399 MHD_gnutls_assert ();
400 FREE_RSA_PRIVATE_PARAMS;
401 return GNUTLS_E_MPI_SCAN_FAILED;
402 }
403
404 siz = p->size;
405 if (MHD_gtls_mpi_scan_nz (&key->params[3], p->data, &siz))
406 {
407 MHD_gnutls_assert ();
408 FREE_RSA_PRIVATE_PARAMS;
409 return GNUTLS_E_MPI_SCAN_FAILED;
410 }
411
412 siz = q->size;
413 if (MHD_gtls_mpi_scan_nz (&key->params[4], q->data, &siz))
414 {
415 MHD_gnutls_assert ();
416 FREE_RSA_PRIVATE_PARAMS;
417 return GNUTLS_E_MPI_SCAN_FAILED;
418 }
419
420#ifdef CALC_COEFF
421 key->params[5] =
422 MHD__gnutls_mpi_snew (MHD__gnutls_mpi_get_nbits (key->params[0]));
423
424 if (key->params[5] == NULL)
425 {
426 MHD_gnutls_assert ();
427 FREE_RSA_PRIVATE_PARAMS;
428 return GNUTLS_E_MEMORY_ERROR;
429 }
430
431 MHD__gnutls_mpi_invm (key->params[5], key->params[3], key->params[4]);
432#else
433 siz = u->size;
434 if (MHD_gtls_mpi_scan_nz (&key->params[5], u->data, &siz))
435 {
436 MHD_gnutls_assert ();
437 FREE_RSA_PRIVATE_PARAMS;
438 return GNUTLS_E_MPI_SCAN_FAILED;
439 }
440#endif
441
442 if (!key->crippled)
443 {
444 ret = MHD__gnutls_asn1_encode_rsa (&key->key, key->params);
445 if (ret < 0)
446 {
447 MHD_gnutls_assert ();
448 FREE_RSA_PRIVATE_PARAMS;
449 return ret;
450 }
451 }
452
453 key->params_size = RSA_PRIVATE_PARAMS;
454 key->pk_algorithm = MHD_GNUTLS_PK_RSA;
455
456 return 0;
457
458}
459
460/**
461 * MHD_gnutls_x509_privkey_get_pk_algorithm - This function returns the key's PublicKey algorithm
462 * @key: should contain a MHD_gnutls_x509_privkey_t structure
463 *
464 * This function will return the public key algorithm of a private
465 * key.
466 *
467 * Returns a member of the enum MHD_GNUTLS_PublicKeyAlgorithm enumeration on success,
468 * or a negative value on error.
469 *
470 **/
471int
472MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key)
473{
474 if (key == NULL)
475 {
476 MHD_gnutls_assert ();
477 return GNUTLS_E_INVALID_REQUEST;
478 }
479
480 return key->pk_algorithm;
481}
482
483/* Encodes the RSA parameters into an ASN.1 RSA private key structure.
484 */
485static int
486MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
487{
488 int result, i;
489 size_t size[8], total;
490 opaque *m_data, *pube_data, *prie_data;
491 opaque *p1_data, *p2_data, *u_data, *exp1_data, *exp2_data;
492 opaque *all_data = NULL, *p;
493 mpi_t exp1 = NULL, exp2 = NULL, q1 = NULL, p1 = NULL, u = NULL;
494 opaque null = '\0';
495
496 /* Read all the sizes */
497 total = 0;
498 for (i = 0; i < 5; i++)
499 {
500 MHD_gtls_mpi_print_lz (NULL, &size[i], params[i]);
501 total += size[i];
502 }
503
504 /* Now generate exp1 and exp2
505 */
506 exp1 = MHD__gnutls_mpi_salloc_like (params[0]); /* like modulus */
507 if (exp1 == NULL)
508 {
509 MHD_gnutls_assert ();
510 result = GNUTLS_E_MEMORY_ERROR;
511 goto cleanup;
512 }
513
514 exp2 = MHD__gnutls_mpi_salloc_like (params[0]);
515 if (exp2 == NULL)
516 {
517 MHD_gnutls_assert ();
518 result = GNUTLS_E_MEMORY_ERROR;
519 goto cleanup;
520 }
521
522 q1 = MHD__gnutls_mpi_salloc_like (params[4]);
523 if (q1 == NULL)
524 {
525 MHD_gnutls_assert ();
526 result = GNUTLS_E_MEMORY_ERROR;
527 goto cleanup;
528 }
529
530 p1 = MHD__gnutls_mpi_salloc_like (params[3]);
531 if (p1 == NULL)
532 {
533 MHD_gnutls_assert ();
534 result = GNUTLS_E_MEMORY_ERROR;
535 goto cleanup;
536 }
537
538 u = MHD__gnutls_mpi_salloc_like (params[3]);
539 if (u == NULL)
540 {
541 MHD_gnutls_assert ();
542 result = GNUTLS_E_MEMORY_ERROR;
543 goto cleanup;
544 }
545
546 MHD__gnutls_mpi_invm (u, params[4], params[3]);
547 /* inverse of q mod p */
548 MHD_gtls_mpi_print_lz (NULL, &size[5], u);
549 total += size[5];
550
551 MHD__gnutls_mpi_sub_ui (p1, params[3], 1);
552 MHD__gnutls_mpi_sub_ui (q1, params[4], 1);
553
554 MHD__gnutls_mpi_mod (exp1, params[2], p1);
555 MHD__gnutls_mpi_mod (exp2, params[2], q1);
556
557 /* calculate exp's size */
558 MHD_gtls_mpi_print_lz (NULL, &size[6], exp1);
559 total += size[6];
560
561 MHD_gtls_mpi_print_lz (NULL, &size[7], exp2);
562 total += size[7];
563
564 /* Encoding phase.
565 * allocate data enough to hold everything
566 */
567 all_data = MHD_gnutls_secure_malloc (total);
568 if (all_data == NULL)
569 {
570 MHD_gnutls_assert ();
571 result = GNUTLS_E_MEMORY_ERROR;
572 goto cleanup;
573 }
574
575 p = all_data;
576 m_data = p;
577 p += size[0];
578 pube_data = p;
579 p += size[1];
580 prie_data = p;
581 p += size[2];
582 p1_data = p;
583 p += size[3];
584 p2_data = p;
585 p += size[4];
586 u_data = p;
587 p += size[5];
588 exp1_data = p;
589 p += size[6];
590 exp2_data = p;
591
592 MHD_gtls_mpi_print_lz (m_data, &size[0], params[0]);
593 MHD_gtls_mpi_print_lz (pube_data, &size[1], params[1]);
594 MHD_gtls_mpi_print_lz (prie_data, &size[2], params[2]);
595 MHD_gtls_mpi_print_lz (p1_data, &size[3], params[3]);
596 MHD_gtls_mpi_print_lz (p2_data, &size[4], params[4]);
597 MHD_gtls_mpi_print_lz (u_data, &size[5], u);
598 MHD_gtls_mpi_print_lz (exp1_data, &size[6], exp1);
599 MHD_gtls_mpi_print_lz (exp2_data, &size[7], exp2);
600
601 /* Ok. Now we have the data. Create the asn1 structures
602 */
603
604 if ((result =
605 MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
606 "GNUTLS.RSAPrivateKey", c2)) != ASN1_SUCCESS)
607 {
608 MHD_gnutls_assert ();
609 result = MHD_gtls_asn2err (result);
610 goto cleanup;
611 }
612
613 /* Write PRIME
614 */
615 if ((result = MHD__asn1_write_value (*c2, "modulus", m_data, size[0]))
616 != ASN1_SUCCESS)
617 {
618 MHD_gnutls_assert ();
619 result = MHD_gtls_asn2err (result);
620 goto cleanup;
621 }
622
623 if ((result =
624 MHD__asn1_write_value (*c2, "publicExponent", pube_data,
625 size[1])) != ASN1_SUCCESS)
626 {
627 MHD_gnutls_assert ();
628 result = MHD_gtls_asn2err (result);
629 goto cleanup;
630 }
631
632 if ((result =
633 MHD__asn1_write_value (*c2, "privateExponent", prie_data,
634 size[2])) != ASN1_SUCCESS)
635 {
636 MHD_gnutls_assert ();
637 result = MHD_gtls_asn2err (result);
638 goto cleanup;
639 }
640
641 if ((result = MHD__asn1_write_value (*c2, "prime1", p1_data, size[3]))
642 != ASN1_SUCCESS)
643 {
644 MHD_gnutls_assert ();
645 result = MHD_gtls_asn2err (result);
646 goto cleanup;
647 }
648
649 if ((result = MHD__asn1_write_value (*c2, "prime2", p2_data, size[4]))
650 != ASN1_SUCCESS)
651 {
652 MHD_gnutls_assert ();
653 result = MHD_gtls_asn2err (result);
654 goto cleanup;
655 }
656
657 if ((result = MHD__asn1_write_value (*c2, "exponent1", exp1_data, size[6]))
658 != ASN1_SUCCESS)
659 {
660 MHD_gnutls_assert ();
661 result = MHD_gtls_asn2err (result);
662 goto cleanup;
663 }
664
665 if ((result = MHD__asn1_write_value (*c2, "exponent2", exp2_data, size[7]))
666 != ASN1_SUCCESS)
667 {
668 MHD_gnutls_assert ();
669 result = MHD_gtls_asn2err (result);
670 goto cleanup;
671 }
672
673 if ((result = MHD__asn1_write_value (*c2, "coefficient", u_data, size[5]))
674 != ASN1_SUCCESS)
675 {
676 MHD_gnutls_assert ();
677 result = MHD_gtls_asn2err (result);
678 goto cleanup;
679 }
680
681 MHD_gtls_mpi_release (&exp1);
682 MHD_gtls_mpi_release (&exp2);
683 MHD_gtls_mpi_release (&q1);
684 MHD_gtls_mpi_release (&p1);
685 MHD_gtls_mpi_release (&u);
686 MHD_gnutls_free (all_data);
687
688 if ((result = MHD__asn1_write_value (*c2, "otherPrimeInfos",
689 NULL, 0)) != ASN1_SUCCESS)
690 {
691 MHD_gnutls_assert ();
692 result = MHD_gtls_asn2err (result);
693 goto cleanup;
694 }
695
696 if ((result =
697 MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
698 {
699 MHD_gnutls_assert ();
700 result = MHD_gtls_asn2err (result);
701 goto cleanup;
702 }
703
704 return 0;
705
706cleanup:MHD_gtls_mpi_release (&u);
707 MHD_gtls_mpi_release (&exp1);
708 MHD_gtls_mpi_release (&exp2);
709 MHD_gtls_mpi_release (&q1);
710 MHD_gtls_mpi_release (&p1);
711 MHD__asn1_delete_structure (c2);
712 MHD_gnutls_free (all_data);
713
714 return result;
715}
716
717/* Encodes the DSA parameters into an ASN.1 DSAPrivateKey structure.
718 */
719int
720MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
721{
722 int result, i;
723 size_t size[DSA_PRIVATE_PARAMS], total;
724 opaque *p_data, *q_data, *g_data, *x_data, *y_data;
725 opaque *all_data = NULL, *p;
726 opaque null = '\0';
727
728 /* Read all the sizes */
729 total = 0;
730 for (i = 0; i < DSA_PRIVATE_PARAMS; i++)
731 {
732 MHD_gtls_mpi_print_lz (NULL, &size[i], params[i]);
733 total += size[i];
734 }
735
736 /* Encoding phase.
737 * allocate data enough to hold everything
738 */
739 all_data = MHD_gnutls_secure_malloc (total);
740 if (all_data == NULL)
741 {
742 MHD_gnutls_assert ();
743 result = GNUTLS_E_MEMORY_ERROR;
744 goto cleanup;
745 }
746
747 p = all_data;
748 p_data = p;
749 p += size[0];
750 q_data = p;
751 p += size[1];
752 g_data = p;
753 p += size[2];
754 y_data = p;
755 p += size[3];
756 x_data = p;
757
758 MHD_gtls_mpi_print_lz (p_data, &size[0], params[0]);
759 MHD_gtls_mpi_print_lz (q_data, &size[1], params[1]);
760 MHD_gtls_mpi_print_lz (g_data, &size[2], params[2]);
761 MHD_gtls_mpi_print_lz (y_data, &size[3], params[3]);
762 MHD_gtls_mpi_print_lz (x_data, &size[4], params[4]);
763
764 /* Ok. Now we have the data. Create the asn1 structures
765 */
766
767 if ((result =
768 MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
769 "GNUTLS.DSAPrivateKey", c2)) != ASN1_SUCCESS)
770 {
771 MHD_gnutls_assert ();
772 result = MHD_gtls_asn2err (result);
773 goto cleanup;
774 }
775
776 /* Write PRIME
777 */
778 if ((result =
779 MHD__asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
780 {
781 MHD_gnutls_assert ();
782 result = MHD_gtls_asn2err (result);
783 goto cleanup;
784 }
785
786 if ((result =
787 MHD__asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
788 {
789 MHD_gnutls_assert ();
790 result = MHD_gtls_asn2err (result);
791 goto cleanup;
792 }
793
794 if ((result =
795 MHD__asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
796 {
797 MHD_gnutls_assert ();
798 result = MHD_gtls_asn2err (result);
799 goto cleanup;
800 }
801
802 if ((result =
803 MHD__asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
804 {
805 MHD_gnutls_assert ();
806 result = MHD_gtls_asn2err (result);
807 goto cleanup;
808 }
809
810 if ((result =
811 MHD__asn1_write_value (*c2, "priv", x_data, size[4])) != ASN1_SUCCESS)
812 {
813 MHD_gnutls_assert ();
814 result = MHD_gtls_asn2err (result);
815 goto cleanup;
816 }
817
818 MHD_gnutls_free (all_data);
819
820 if ((result =
821 MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
822 {
823 MHD_gnutls_assert ();
824 result = MHD_gtls_asn2err (result);
825 goto cleanup;
826 }
827
828 return 0;
829
830cleanup:MHD__asn1_delete_structure (c2);
831 MHD_gnutls_free (all_data);
832
833 return result;
834}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-19 00:07:12 +0000