← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gnutls26/quantal-security

« back to all changes in this revision

Viewing changes to lib/x509/output.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2011-05-20 13:07:18 UTC
  • mfrom: (12.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110520130718-db41dybbanzfvlji
Tags: 2.10.5-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Fix build failure with --no-add-needed.
  - Build for multiarch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/x509/output.c
1
1
/*
2
 
 * Copyright (C) 2007, 2008, 2009 Free Software Foundation
 
2
 * Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
3
3
 *
4
4
 * Author: Simon Josefsson
5
5
 *
6
 
 * This file is part of GNUTLS.
 
6
 * This file is part of GnuTLS.
7
7
 *
8
 
 * The GNUTLS library is free software; you can redistribute it and/or
 
8
 * The GnuTLS is free software; you can redistribute it and/or
9
9
 * modify it under the terms of the GNU Lesser General Public License
10
10
 * as published by the Free Software Foundation; either version 2.1 of
11
11
 * the License, or (at your option) any later version.
188
188
  buffer = gnutls_malloc (size);
189
189
  if (!buffer)
190
190
    {
191
 
      addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
191
      addf (str, "error: malloc: %s\n",
 
192
            gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
192
193
      return;
193
194
    }
194
195
 
211
212
#define TYPE_CRT 2
212
213
#define TYPE_CRQ 3
213
214
 
 
215
#define TYPE_CRT_SAN TYPE_CRT
 
216
#define TYPE_CRQ_SAN TYPE_CRQ
 
217
#define TYPE_CRT_IAN 4
 
218
 
214
219
typedef union
215
220
{
216
221
  gnutls_x509_crt_t crt;
246
251
  buffer = gnutls_malloc (size);
247
252
  if (!buffer)
248
253
    {
249
 
      addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
254
      addf (str, "error: malloc: %s\n",
 
255
            gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
250
256
      return;
251
257
    }
252
258
 
340
346
      buffer = gnutls_malloc (size);
341
347
      if (!buffer)
342
348
        {
343
 
          addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
349
          addf (str, "error: malloc: %s\n",
 
350
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
344
351
          return;
345
352
        }
346
353
 
356
363
 
357
364
      if ((err == GNUTLS_SAN_DNSNAME
358
365
           || err == GNUTLS_SAN_RFC822NAME
359
 
           || err == GNUTLS_SAN_URI) &&
360
 
          strlen (buffer) != size)
 
366
           || err == GNUTLS_SAN_URI) && strlen (buffer) != size)
361
367
        {
362
368
          adds (str, _("warning: distributionPoint contains an embedded NUL, "
363
369
                       "replacing with '!'\n"));
431
437
      buffer = gnutls_malloc (size);
432
438
      if (!buffer)
433
439
        {
434
 
          addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
440
          addf (str, "error: malloc: %s\n",
 
441
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
435
442
          return;
436
443
        }
437
444
 
462
469
        addf (str, _("%s\t\t\tTime stamping.\n"), prefix);
463
470
      else if (strcmp (buffer, GNUTLS_KP_OCSP_SIGNING) == 0)
464
471
        addf (str, _("%s\t\t\tOCSP signing.\n"), prefix);
 
472
      else if (strcmp (buffer, GNUTLS_KP_IPSEC_IKE) == 0)
 
473
        addf (str, _("%s\t\t\tIpsec IKE.\n"), prefix);
465
474
      else if (strcmp (buffer, GNUTLS_KP_ANY) == 0)
466
475
        addf (str, _("%s\t\t\tAny purpose.\n"), prefix);
467
476
      else
506
515
 
507
516
 
508
517
static void
509
 
print_san (gnutls_string * str, const char *prefix, int type,
510
 
           cert_type_t cert)
 
518
print_altname (gnutls_string * str, const char *prefix, int altname_type,
 
519
               cert_type_t cert)
511
520
{
512
 
  unsigned int san_idx;
 
521
  unsigned int altname_idx;
513
522
  char str_ip[64];
514
523
  char *p;
515
524
 
516
 
  for (san_idx = 0;; san_idx++)
 
525
  for (altname_idx = 0;; altname_idx++)
517
526
    {
518
527
      char *buffer = NULL;
519
528
      size_t size = 0;
520
529
      int err;
521
530
 
522
 
      if (type == TYPE_CRT)
 
531
      if (altname_type == TYPE_CRT_SAN)
523
532
        err =
524
 
          gnutls_x509_crt_get_subject_alt_name (cert.crt, san_idx, buffer,
 
533
          gnutls_x509_crt_get_subject_alt_name (cert.crt, altname_idx, buffer,
525
534
                                                &size, NULL);
526
 
      else if (type == TYPE_CRQ)
 
535
      else if (altname_type == TYPE_CRQ_SAN)
527
536
        err =
528
 
          gnutls_x509_crq_get_subject_alt_name (cert.crq, san_idx, buffer,
 
537
          gnutls_x509_crq_get_subject_alt_name (cert.crq, altname_idx, buffer,
529
538
                                                &size, NULL, NULL);
 
539
      else if (altname_type == TYPE_CRT_IAN)
 
540
        err =
 
541
          gnutls_x509_crt_get_issuer_alt_name (cert.crt, altname_idx, buffer,
 
542
                                               &size, NULL);
530
543
      else
531
544
        return;
532
545
 
534
547
        break;
535
548
      if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
536
549
        {
537
 
          addf (str, "error: get_subject_alt_name: %s\n",
 
550
          addf (str, "error: get_subject/issuer_alt_name: %s\n",
538
551
                gnutls_strerror (err));
539
552
          return;
540
553
        }
542
555
      buffer = gnutls_malloc (size);
543
556
      if (!buffer)
544
557
        {
545
 
          addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
558
          addf (str, "error: malloc: %s\n",
 
559
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
546
560
          return;
547
561
        }
548
562
 
549
 
      if (type == TYPE_CRT)
 
563
      if (altname_type == TYPE_CRT_SAN)
550
564
        err =
551
 
          gnutls_x509_crt_get_subject_alt_name (cert.crt, san_idx, buffer,
 
565
          gnutls_x509_crt_get_subject_alt_name (cert.crt, altname_idx, buffer,
552
566
                                                &size, NULL);
553
 
      else if (type == TYPE_CRQ)
 
567
      else if (altname_type == TYPE_CRQ_SAN)
554
568
        err =
555
 
          gnutls_x509_crq_get_subject_alt_name (cert.crq, san_idx, buffer,
 
569
          gnutls_x509_crq_get_subject_alt_name (cert.crq, altname_idx, buffer,
556
570
                                                &size, NULL, NULL);
 
571
      else if (altname_type == TYPE_CRT_IAN)
 
572
        err = gnutls_x509_crt_get_issuer_alt_name (cert.crt, altname_idx,
 
573
                                                   buffer, &size, NULL);
557
574
 
558
575
      if (err < 0)
559
576
        {
560
577
          gnutls_free (buffer);
561
 
          addf (str, "error: get_subject_alt_name2: %s\n",
 
578
          addf (str, "error: get_subject/issuer_alt_name2: %s\n",
562
579
                gnutls_strerror (err));
563
580
          return;
564
581
        }
565
582
 
566
583
      if ((err == GNUTLS_SAN_DNSNAME
567
584
           || err == GNUTLS_SAN_RFC822NAME
568
 
           || err == GNUTLS_SAN_URI) &&
569
 
          strlen (buffer) != size)
 
585
           || err == GNUTLS_SAN_URI) && strlen (buffer) != size)
570
586
        {
571
 
          adds (str, _("warning: SAN contains an embedded NUL, "
 
587
          adds (str, _("warning: altname contains an embedded NUL, "
572
588
                       "replacing with '!'\n"));
573
589
          while (strlen (buffer) < size)
574
590
            buffer[strlen (buffer)] = '!';
581
597
          break;
582
598
 
583
599
        case GNUTLS_SAN_RFC822NAME:
584
 
          addf (str, "%s\t\t\tRFC822name: %.*s\n", prefix, (int) size, buffer);
 
600
          addf (str, "%s\t\t\tRFC822name: %.*s\n", prefix, (int) size,
 
601
                buffer);
585
602
          break;
586
603
 
587
604
        case GNUTLS_SAN_URI:
606
623
            size_t oidsize;
607
624
 
608
625
            oidsize = 0;
609
 
            if (type == TYPE_CRT)
 
626
            if (altname_type == TYPE_CRT_SAN)
610
627
              err = gnutls_x509_crt_get_subject_alt_othername_oid
611
 
                (cert.crt, san_idx, oid, &oidsize);
612
 
            else if (type == TYPE_CRQ)
 
628
                (cert.crt, altname_idx, oid, &oidsize);
 
629
            else if (altname_type == TYPE_CRQ_SAN)
613
630
              err = gnutls_x509_crq_get_subject_alt_othername_oid
614
 
                (cert.crq, san_idx, oid, &oidsize);
 
631
                (cert.crq, altname_idx, oid, &oidsize);
 
632
            else if (altname_type == TYPE_CRT_IAN)
 
633
              err = gnutls_x509_crt_get_issuer_alt_othername_oid
 
634
                (cert.crt, altname_idx, oid, &oidsize);
615
635
 
616
636
            if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
617
637
              {
618
638
                gnutls_free (buffer);
619
 
                addf (str, "error: get_subject_alt_othername_oid: %s\n",
 
639
                addf (str,
 
640
                      "error: get_subject/issuer_alt_othername_oid: %s\n",
620
641
                      gnutls_strerror (err));
621
642
                return;
622
643
              }
625
646
            if (!oid)
626
647
              {
627
648
                gnutls_free (buffer);
628
 
                addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
649
                addf (str, "error: malloc: %s\n",
 
650
                      gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
629
651
                return;
630
652
              }
631
653
 
632
 
            if (type == TYPE_CRT)
 
654
            if (altname_type == TYPE_CRT_SAN)
633
655
              err = gnutls_x509_crt_get_subject_alt_othername_oid
634
 
                (cert.crt, san_idx, oid, &oidsize);
635
 
            else if (type == TYPE_CRQ)
 
656
                (cert.crt, altname_idx, oid, &oidsize);
 
657
            else if (altname_type == TYPE_CRQ_SAN)
636
658
              err = gnutls_x509_crq_get_subject_alt_othername_oid
637
 
                (cert.crq, san_idx, oid, &oidsize);
 
659
                (cert.crq, altname_idx, oid, &oidsize);
 
660
            else if (altname_type == TYPE_CRT_IAN)
 
661
              err = gnutls_x509_crt_get_issuer_alt_othername_oid
 
662
                (cert.crt, altname_idx, oid, &oidsize);
 
663
 
638
664
            if (err < 0)
639
665
              {
640
666
                gnutls_free (buffer);
648
674
              {
649
675
                if (strlen (buffer) != size)
650
676
                  {
651
 
                    adds (str, _("warning: SAN contains an embedded NUL, "
 
677
                    adds (str, _("warning: altname contains an embedded NUL, "
652
678
                                 "replacing with '!'\n"));
653
679
                    while (strlen (buffer) < size)
654
680
                      buffer[strlen (buffer)] = '!';
672
698
          break;
673
699
 
674
700
        default:
675
 
          addf (str, "error: unknown SAN\n");
 
701
          addf (str, "error: unknown altname\n");
676
702
          break;
677
703
        }
678
704
 
685
711
                  cert_type_t cert)
686
712
{
687
713
  int i, err;
 
714
  int san_idx = 0;
 
715
  int ian_idx = 0;
 
716
  int proxy_idx = 0;
 
717
  int basic_idx = 0;
 
718
  int keyusage_idx = 0;
 
719
  int keypurpose_idx = 0;
 
720
  int ski_idx = 0;
 
721
  int aki_idx = 0;
 
722
  int crldist_idx = 0;
688
723
 
689
724
  for (i = 0;; i++)
690
725
    {
691
726
      char oid[MAX_OID_SIZE] = "";
692
727
      size_t sizeof_oid = sizeof (oid);
693
728
      int critical;
694
 
      size_t san_idx = 0;
695
 
      size_t proxy_idx = 0;
696
 
      size_t basic_idx = 0;
697
 
      size_t keyusage_idx = 0;
698
 
      size_t keypurpose_idx = 0;
699
 
      size_t ski_idx = 0;
700
 
      size_t aki_idx = 0;
701
 
      size_t crldist_idx = 0;
702
729
 
703
730
      if (type == TYPE_CRT)
704
731
        err = gnutls_x509_crt_get_extension_info (cert.crt, i,
818
845
          addf (str, _("%s\t\tSubject Alternative Name (%s):\n"), prefix,
819
846
                critical ? _("critical") : _("not critical"));
820
847
 
821
 
          print_san (str, prefix, type, cert);
 
848
          print_altname (str, prefix, type, cert);
822
849
 
823
850
          san_idx++;
824
851
        }
 
852
      else if (strcmp (oid, "2.5.29.18") == 0)
 
853
        {
 
854
          if (ian_idx)
 
855
            {
 
856
              addf (str, "error: more than one Issuer AltName extension\n");
 
857
              continue;
 
858
            }
 
859
 
 
860
          addf (str, _("%s\t\tIssuer Alternative Name (%s):\n"), prefix,
 
861
                critical ? _("critical") : _("not critical"));
 
862
 
 
863
          print_altname (str, prefix, TYPE_CRT_IAN, cert);
 
864
 
 
865
          ian_idx++;
 
866
        }
825
867
      else if (strcmp (oid, "2.5.29.31") == 0)
826
868
        {
827
869
          if (crldist_idx)
886
928
          buffer = gnutls_malloc (extlen);
887
929
          if (!buffer)
888
930
            {
889
 
              addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
931
              addf (str, "error: malloc: %s\n",
 
932
                    gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
890
933
              continue;
891
934
            }
892
935
 
952
995
  /* Issuer. */
953
996
  if (!notsigned)
954
997
    {
955
 
      char dn[1024];
956
 
      size_t dn_size = sizeof (dn);
 
998
      char *dn;
 
999
      size_t dn_size = 0;
957
1000
      int err;
958
1001
 
959
 
      err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
960
 
      if (err < 0)
 
1002
      err = gnutls_x509_crt_get_issuer_dn (cert, NULL, &dn_size);
 
1003
      if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
961
1004
        addf (str, "error: get_issuer_dn: %s\n", gnutls_strerror (err));
962
1005
      else
963
 
        addf (str, _("\tIssuer: %s\n"), dn);
 
1006
        {
 
1007
          dn = gnutls_malloc (dn_size);
 
1008
          if (!dn)
 
1009
            addf (str, "error: malloc (%d): %s\n", (int) dn_size,
 
1010
                  gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1011
          else
 
1012
            {
 
1013
              err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
 
1014
              if (err < 0)
 
1015
                addf (str, "error: get_issuer_dn: %s\n",
 
1016
                      gnutls_strerror (err));
 
1017
              else
 
1018
                addf (str, _("\tIssuer: %s\n"), dn);
 
1019
              gnutls_free (dn);
 
1020
            }
 
1021
        }
964
1022
    }
965
1023
 
966
1024
  /* Validity. */
1000
1058
 
1001
1059
  /* Subject. */
1002
1060
  {
1003
 
    char dn[1024];
1004
 
    size_t dn_size = sizeof (dn);
 
1061
    char *dn;
 
1062
    size_t dn_size = 0;
1005
1063
    int err;
1006
1064
 
1007
 
    err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
1008
 
    if (err < 0)
 
1065
    err = gnutls_x509_crt_get_dn (cert, NULL, &dn_size);
 
1066
    if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
1009
1067
      addf (str, "error: get_dn: %s\n", gnutls_strerror (err));
1010
1068
    else
1011
 
      addf (str, _("\tSubject: %s\n"), dn);
 
1069
      {
 
1070
        dn = gnutls_malloc (dn_size);
 
1071
        if (!dn)
 
1072
          addf (str, "error: malloc (%d): %s\n", (int) dn_size,
 
1073
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1074
        else
 
1075
          {
 
1076
            err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
 
1077
            if (err < 0)
 
1078
              addf (str, "error: get_dn: %s\n", gnutls_strerror (err));
 
1079
            else
 
1080
              addf (str, _("\tSubject: %s\n"), dn);
 
1081
            gnutls_free (dn);
 
1082
          }
 
1083
      }
1012
1084
  }
1013
1085
 
1014
1086
  /* SubjectPublicKeyInfo. */
1129
1201
      buffer = gnutls_malloc (size);
1130
1202
      if (!buffer)
1131
1203
        {
1132
 
          addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
1204
          addf (str, "error: malloc: %s\n",
 
1205
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
1133
1206
          return;
1134
1207
        }
1135
1208
 
1204
1277
static void
1205
1278
print_oneline (gnutls_string * str, gnutls_x509_crt_t cert)
1206
1279
{
1207
 
 
1208
1280
  /* Subject. */
1209
1281
  {
1210
 
    char dn[1024];
1211
 
    size_t dn_size = sizeof (dn);
 
1282
    char *dn;
 
1283
    size_t dn_size = 0;
1212
1284
    int err;
1213
1285
 
1214
 
    err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
1215
 
    if (err < 0)
 
1286
    err = gnutls_x509_crt_get_dn (cert, NULL, &dn_size);
 
1287
    if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
1216
1288
      addf (str, "unknown subject (%s), ", gnutls_strerror (err));
1217
1289
    else
1218
 
      addf (str, "subject `%s', ", dn);
 
1290
      {
 
1291
        dn = gnutls_malloc (dn_size);
 
1292
        if (!dn)
 
1293
          addf (str, "unknown subject (%s), ",
 
1294
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1295
        else
 
1296
          {
 
1297
            err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
 
1298
            if (err < 0)
 
1299
              addf (str, "unknown subject (%s), ", gnutls_strerror (err));
 
1300
            else
 
1301
              addf (str, "subject `%s', ", dn);
 
1302
            gnutls_free (dn);
 
1303
          }
 
1304
      }
1219
1305
  }
1220
1306
 
1221
1307
  /* Issuer. */
1222
1308
  {
1223
 
    char dn[1024];
1224
 
    size_t dn_size = sizeof (dn);
 
1309
    char *dn;
 
1310
    size_t dn_size = 0;
1225
1311
    int err;
1226
1312
 
1227
 
    err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
1228
 
    if (err < 0)
 
1313
    err = gnutls_x509_crt_get_issuer_dn (cert, NULL, &dn_size);
 
1314
    if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
1229
1315
      addf (str, "unknown issuer (%s), ", gnutls_strerror (err));
1230
1316
    else
1231
 
      addf (str, "issuer `%s', ", dn);
 
1317
      {
 
1318
        dn = gnutls_malloc (dn_size);
 
1319
        if (!dn)
 
1320
          addf (str, "unknown issuer (%s), ",
 
1321
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1322
        else
 
1323
          {
 
1324
            err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
 
1325
            if (err < 0)
 
1326
              addf (str, "unknown issuer (%s), ", gnutls_strerror (err));
 
1327
            else
 
1328
              addf (str, "issuer `%s', ", dn);
 
1329
            gnutls_free (dn);
 
1330
          }
 
1331
      }
1232
1332
  }
1233
1333
 
1234
1334
  /* Key algorithm and size. */
1247
1347
 
1248
1348
    err = gnutls_x509_crt_get_signature_algorithm (cert);
1249
1349
    if (err < 0)
1250
 
      addf (str, "unknown signature algorithm (%s), ",
1251
 
            gnutls_strerror (err));
 
1350
      addf (str, "unknown signature algorithm (%s), ", gnutls_strerror (err));
1252
1351
    else
1253
1352
      {
1254
1353
        const char *name = gnutls_sign_algorithm_get_name (err);
1340
1439
}
1341
1440
 
1342
1441
/**
1343
 
 * gnutls_x509_crt_print - Pretty print X.509 certificates
 
1442
 * gnutls_x509_crt_print:
1344
1443
 * @cert: The structure to be printed
1345
1444
 * @format: Indicate the format to use
1346
1445
 * @out: Newly allocated datum with zero terminated string.
1420
1519
  /* Issuer. */
1421
1520
  if (!notsigned)
1422
1521
    {
1423
 
      char dn[1024];
1424
 
      size_t dn_size = sizeof (dn);
 
1522
      char *dn;
 
1523
      size_t dn_size = 0;
1425
1524
      int err;
1426
1525
 
1427
 
      err = gnutls_x509_crl_get_issuer_dn (crl, dn, &dn_size);
1428
 
      if (err < 0)
 
1526
      err = gnutls_x509_crl_get_issuer_dn (crl, NULL, &dn_size);
 
1527
      if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
1429
1528
        addf (str, "error: get_issuer_dn: %s\n", gnutls_strerror (err));
1430
1529
      else
1431
 
        addf (str, _("\tIssuer: %s\n"), dn);
 
1530
        {
 
1531
          dn = gnutls_malloc (dn_size);
 
1532
          if (!dn)
 
1533
            addf (str, "error: malloc (%d): %s\n", (int) dn_size,
 
1534
                  gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1535
          else
 
1536
            {
 
1537
              err = gnutls_x509_crl_get_issuer_dn (crl, dn, &dn_size);
 
1538
              if (err < 0)
 
1539
                addf (str, "error: get_issuer_dn: %s\n",
 
1540
                      gnutls_strerror (err));
 
1541
              else
 
1542
                addf (str, _("\tIssuer: %s\n"), dn);
 
1543
            }
 
1544
          gnutls_free (dn);
 
1545
        }
1432
1546
    }
1433
1547
 
1434
1548
  /* Validity. */
1473
1587
    {
1474
1588
      size_t i;
1475
1589
      int err = 0;
 
1590
      int aki_idx = 0;
 
1591
      int crl_nr = 0;
1476
1592
 
1477
1593
      for (i = 0;; i++)
1478
1594
        {
1479
1595
          char oid[MAX_OID_SIZE] = "";
1480
1596
          size_t sizeof_oid = sizeof (oid);
1481
1597
          int critical;
1482
 
          int crl_nr = 0;
1483
 
          int aki_idx = 0;
1484
1598
 
1485
1599
          err = gnutls_x509_crl_get_extension_info (crl, i,
1486
1600
                                                    oid, &sizeof_oid,
1561
1675
              buffer = gnutls_malloc (extlen);
1562
1676
              if (!buffer)
1563
1677
                {
1564
 
                  addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
1678
                  addf (str, "error: malloc: %s\n",
 
1679
                        gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
1565
1680
                  continue;
1566
1681
                }
1567
1682
 
1664
1779
      buffer = gnutls_malloc (size);
1665
1780
      if (!buffer)
1666
1781
        {
1667
 
          addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
1782
          addf (str, "error: malloc: %s\n",
 
1783
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
1668
1784
          return;
1669
1785
        }
1670
1786
 
1684
1800
}
1685
1801
 
1686
1802
/**
1687
 
 * gnutls_x509_crl_print - Pretty print X.509 certificate revocation list
 
1803
 * gnutls_x509_crl_print:
1688
1804
 * @crl: The structure to be printed
1689
1805
 * @format: Indicate the format to use
1690
1806
 * @out: Newly allocated datum with zero terminated string.
1732
1848
 
1733
1849
  /* Subject */
1734
1850
  {
1735
 
    char dn[1024];
1736
 
    size_t dn_size = sizeof (dn);
 
1851
    char *dn;
 
1852
    size_t dn_size = 0;
1737
1853
    int err;
1738
1854
 
1739
 
    err = gnutls_x509_crq_get_dn (cert, dn, &dn_size);
1740
 
    if (err < 0)
 
1855
    err = gnutls_x509_crq_get_dn (cert, NULL, &dn_size);
 
1856
    if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
1741
1857
      addf (str, "error: get_dn: %s\n", gnutls_strerror (err));
1742
1858
    else
1743
 
      addf (str, _("\tSubject: %s\n"), dn);
 
1859
      {
 
1860
        dn = gnutls_malloc (dn_size);
 
1861
        if (!dn)
 
1862
          addf (str, "error: malloc (%d): %s\n", (int) dn_size,
 
1863
                gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
1864
        else
 
1865
          {
 
1866
            err = gnutls_x509_crq_get_dn (cert, dn, &dn_size);
 
1867
            if (err < 0)
 
1868
              addf (str, "error: get_dn: %s\n", gnutls_strerror (err));
 
1869
            else
 
1870
              addf (str, _("\tSubject: %s\n"), dn);
 
1871
            gnutls_free (dn);
 
1872
          }
 
1873
      }
1744
1874
  }
1745
1875
 
1746
1876
  /* SubjectPublicKeyInfo. */
1820
1950
  {
1821
1951
    size_t i;
1822
1952
    int err = 0;
 
1953
    int extensions = 0;
 
1954
    int challenge = 0;
1823
1955
 
1824
1956
    for (i = 0;; i++)
1825
1957
      {
1826
1958
        char oid[MAX_OID_SIZE] = "";
1827
1959
        size_t sizeof_oid = sizeof (oid);
1828
 
        int extensions = 0;
1829
 
        int challenge = 0;
1830
1960
 
1831
1961
        err = gnutls_x509_crq_get_attribute_info (cert, i, oid, &sizeof_oid);
1832
1962
        if (err < 0)
1858
1988
          }
1859
1989
        else if (strcmp (oid, "1.2.840.113549.1.9.7") == 0)
1860
1990
          {
1861
 
            char pass[1024];
1862
 
            size_t pass_size = sizeof (pass);
 
1991
            char *pass;
 
1992
            size_t size;
1863
1993
 
1864
1994
            if (challenge)
1865
1995
              {
1866
 
                addf (str,
 
1996
                adds (str,
1867
1997
                      "error: more than one Challenge password attribute\n");
1868
1998
                continue;
1869
1999
              }
1870
2000
 
1871
 
            err =
1872
 
              gnutls_x509_crq_get_challenge_password (cert, pass, &pass_size);
 
2001
            err = gnutls_x509_crq_get_challenge_password (cert, NULL, &size);
 
2002
            if (err < 0)
 
2003
              {
 
2004
                addf (str, "error: get_challenge_password: %s\n",
 
2005
                      gnutls_strerror (err));
 
2006
                continue;
 
2007
              }
 
2008
 
 
2009
            size++;
 
2010
 
 
2011
            pass = gnutls_malloc (size);
 
2012
            if (!pass)
 
2013
              {
 
2014
                addf (str, "error: malloc: %s\n",
 
2015
                      gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
 
2016
                continue;
 
2017
              }
 
2018
 
 
2019
            err = gnutls_x509_crq_get_challenge_password (cert, pass, &size);
1873
2020
            if (err < 0)
1874
2021
              addf (str, "error: get_challenge_password: %s\n",
1875
2022
                    gnutls_strerror (err));
1876
2023
            else
1877
2024
              addf (str, _("\t\tChallenge password: %s\n"), pass);
1878
2025
 
 
2026
            gnutls_free (pass);
 
2027
 
1879
2028
            challenge++;
1880
2029
          }
1881
2030
        else
1896
2045
            buffer = gnutls_malloc (extlen);
1897
2046
            if (!buffer)
1898
2047
              {
1899
 
                addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
2048
                addf (str, "error: malloc: %s\n",
 
2049
                      gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
1900
2050
                continue;
1901
2051
              }
1902
2052
 
1941
2091
  buffer = gnutls_malloc (size);
1942
2092
  if (!buffer)
1943
2093
    {
1944
 
      addf (str, "error: malloc: %s\n", gnutls_strerror (err));
 
2094
      addf (str, "error: malloc: %s\n",
 
2095
            gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
1945
2096
      return;
1946
2097
    }
1947
2098
 
1961
2112
}
1962
2113
 
1963
2114
/**
1964
 
 * gnutls_x509_crq_print - Pretty print PKCS 10 certificate request
 
2115
 * gnutls_x509_crq_print:
1965
2116
 * @crq: The structure to be printed
1966
2117
 * @format: Indicate the format to use
1967
2118
 * @out: Newly allocated datum with zero terminated string.