← Back to branch summary

~nutznboltz-deactivatedaccount/ubuntu/precise/gnutls26/fix-lp926350

« back to all changes in this revision

Viewing changes to tests/crq_key_id.c

  • Committer: Package Import Robot
  • Author(s): Andreas Metzler
  • Date: 2011-10-01 15:28:13 UTC
  • mfrom: (12.1.20 sid)
  • Revision ID: package-import@ubuntu.com-20111001152813-yygm1c4cxonfxhzy
Tags: 2.12.11-1
http://bugs.debian.org/640639
* New upstream version.
  + Allow CA importing of 0 certificates to succeed. Closes: #640639
* Add libp11-kit-dev to libgnutls-dev dependencies. (see #643811)
* [20_guiledocstring.diff] guile: Fix docstring extraction with CPP 4.5+.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/crq_key_id.c
1
1
/*
2
 
 * Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 
2
 * Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
3
3
 *
4
4
 * Author: David Marín Carreño
5
5
 *
21
21
 */
22
22
 
23
23
#ifdef HAVE_CONFIG_H
24
 
# include <config.h>
 
24
#include <config.h>
25
25
#endif
26
26
 
27
27
#include <stdlib.h>
28
28
#include <stdio.h>
29
29
#include <string.h>
30
 
#include <gcrypt.h>
31
30
#include <gnutls/gnutls.h>
32
31
#include <gnutls/x509.h>
 
32
#include <gnutls/abstract.h>
33
33
 
34
34
#include "utils.h"
35
35
 
43
43
doit (void)
44
44
{
45
45
  gnutls_x509_privkey_t pkey;
 
46
  gnutls_privkey_t abs_pkey;
46
47
  gnutls_x509_crq_t crq;
47
48
 
48
49
  size_t pkey_key_id_len;
59
60
  if (ret < 0)
60
61
    fail ("gnutls_global_init: %d\n", ret);
61
62
 
62
 
  gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
63
 
 
64
63
  gnutls_global_set_log_function (tls_log_func);
65
64
  if (debug)
66
65
    gnutls_global_set_log_level (4711);
69
68
    {
70
69
      ret = gnutls_x509_crq_init (&crq);
71
70
      if (ret < 0)
72
 
        fail ("gnutls_x509_crq_init: %d\n", ret);
 
71
        fail ("gnutls_x509_crq_init: %d\n", ret);
73
72
 
74
73
      ret = gnutls_x509_privkey_init (&pkey);
75
74
      if (ret < 0)
76
 
        {
77
 
          fail ("gnutls_x509_privkey_init: %d\n", ret);
78
 
        }
 
75
        {
 
76
          fail ("gnutls_x509_privkey_init: %d\n", ret);
 
77
        }
 
78
 
 
79
      ret = gnutls_privkey_init (&abs_pkey);
 
80
      if (ret < 0)
 
81
        {
 
82
          fail ("gnutls_privkey_init: %d\n", ret);
 
83
        }
79
84
 
80
85
      ret = gnutls_x509_privkey_generate (pkey, algorithm, 1024, 0);
81
86
      if (ret < 0)
82
 
        {
83
 
          fail ("gnutls_x509_privkey_generate (rsa): %d\n", ret);
84
 
        }
 
87
        {
 
88
          fail ("gnutls_x509_privkey_generate (rsa): %d\n", ret);
 
89
        }
85
90
      else if (debug)
86
 
        {
87
 
          success ("Key[%s] generation ok: %d\n",
88
 
                   gnutls_pk_algorithm_get_name (algorithm), ret);
89
 
        }
 
91
        {
 
92
          success ("Key[%s] generation ok: %d\n",
 
93
                   gnutls_pk_algorithm_get_name (algorithm), ret);
 
94
        }
90
95
 
91
96
      pkey_key_id_len = 0;
92
97
      ret = gnutls_x509_privkey_get_key_id (pkey, 0, pkey_key_id,
93
 
                                            &pkey_key_id_len);
 
98
                                            &pkey_key_id_len);
94
99
      if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
95
 
        {
96
 
          fail ("gnutls_x509_privkey_get_key_id incorrectly returns %d\n",
97
 
                ret);
98
 
        }
 
100
        {
 
101
          fail ("gnutls_x509_privkey_get_key_id incorrectly returns %d\n",
 
102
                ret);
 
103
        }
99
104
 
100
105
      pkey_key_id = malloc (sizeof (unsigned char) * pkey_key_id_len);
101
106
      ret = gnutls_x509_privkey_get_key_id (pkey, 0, pkey_key_id,
102
 
                                            &pkey_key_id_len);
 
107
                                            &pkey_key_id_len);
103
108
      if (ret != GNUTLS_E_SUCCESS)
104
 
        {
105
 
          fail ("gnutls_x509_privkey_get_key_id incorrectly returns %d\n",
106
 
                ret);
107
 
        }
 
109
        {
 
110
          fail ("gnutls_x509_privkey_get_key_id incorrectly returns %d\n",
 
111
                ret);
 
112
        }
108
113
 
109
114
      ret = gnutls_x509_crq_set_version (crq, 1);
110
115
      if (ret < 0)
111
 
        {
112
 
          fail ("gnutls_x509_crq_set_version: %d\n", ret);
113
 
        }
 
116
        {
 
117
          fail ("gnutls_x509_crq_set_version: %d\n", ret);
 
118
        }
114
119
 
115
120
      ret = gnutls_x509_crq_set_key (crq, pkey);
116
121
      if (ret < 0)
117
 
        {
118
 
          fail ("gnutls_x509_crq_set_key: %d\n", ret);
119
 
        }
 
122
        {
 
123
          fail ("gnutls_x509_crq_set_key: %d\n", ret);
 
124
        }
120
125
 
121
126
      ret = gnutls_x509_crq_set_dn_by_oid (crq, GNUTLS_OID_X520_COMMON_NAME,
122
 
                                           0, "CN-Test", 7);
123
 
      if (ret < 0)
124
 
        {
125
 
          fail ("gnutls_x509_crq_set_dn_by_oid: %d\n", ret);
126
 
        }
127
 
 
128
 
      ret = gnutls_x509_crq_sign (crq, pkey);
129
 
      if (ret)
130
 
        {
131
 
          fail ("gnutls_x509_crq_sign: %d\n", ret);
132
 
        }
 
127
                                           0, "CN-Test", 7);
 
128
      if (ret < 0)
 
129
        {
 
130
          fail ("gnutls_x509_crq_set_dn_by_oid: %d\n", ret);
 
131
        }
 
132
 
 
133
      ret = gnutls_privkey_import_x509( abs_pkey, pkey, 0);
 
134
      if (ret < 0)
 
135
        {
 
136
          fail ("gnutls_privkey_import_x509: %d\n", ret);
 
137
        }
 
138
 
 
139
      ret = gnutls_x509_crq_privkey_sign (crq, abs_pkey, GNUTLS_DIG_SHA1, 0);
 
140
      if (ret < 0)
 
141
        {
 
142
          fail ("gnutls_x509_crq_sign: %d\n", ret);
 
143
        }
 
144
 
 
145
      ret = gnutls_x509_crq_verify (crq, 0);
 
146
      if (ret < 0)
 
147
        {
 
148
          fail ("gnutls_x509_crq_verify: %d\n", ret);
 
149
        }
133
150
 
134
151
      crq_key_id_len = 0;
135
152
      ret = gnutls_x509_crq_get_key_id (crq, 0, crq_key_id, &crq_key_id_len);
136
153
      if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
137
 
        {
138
 
          fail ("gnutls_x509_crq_get_key_id incorrectly returns %d\n", ret);
139
 
        }
 
154
        {
 
155
          fail ("gnutls_x509_crq_get_key_id incorrectly returns %d\n", ret);
 
156
        }
140
157
 
141
158
      crq_key_id = malloc (sizeof (unsigned char) * crq_key_id_len);
142
159
      ret = gnutls_x509_crq_get_key_id (crq, 0, crq_key_id, &crq_key_id_len);
143
160
      if (ret != GNUTLS_E_SUCCESS)
144
 
        {
145
 
          fail ("gnutls_x509_crq_get_key_id incorrectly returns %d\n", ret);
146
 
        }
 
161
        {
 
162
          fail ("gnutls_x509_crq_get_key_id incorrectly returns %d\n", ret);
 
163
        }
147
164
 
148
165
      if (crq_key_id_len == pkey_key_id_len)
149
 
        {
150
 
          ret = memcmp (crq_key_id, pkey_key_id, crq_key_id_len);
151
 
          if (ret == 0)
152
 
            {
153
 
              if (debug)
154
 
                success ("Key ids are identical. OK.\n");
155
 
            }
156
 
          else
157
 
            {
158
 
              fail ("Key ids differ incorrectly: %d\n", ret);
159
 
            }
160
 
        }
 
166
        {
 
167
          ret = memcmp (crq_key_id, pkey_key_id, crq_key_id_len);
 
168
          if (ret == 0)
 
169
            {
 
170
              if (debug)
 
171
                success ("Key ids are identical. OK.\n");
 
172
            }
 
173
          else
 
174
            {
 
175
              fail ("Key ids differ incorrectly: %d\n", ret);
 
176
            }
 
177
        }
161
178
      else
162
 
        {
163
 
          fail ("Key_id lengths differ incorrectly: %d - %d\n",
164
 
                (int) crq_key_id_len, (int) pkey_key_id_len);
165
 
        }
 
179
        {
 
180
          fail ("Key_id lengths differ incorrectly: %d - %d\n",
 
181
                (int) crq_key_id_len, (int) pkey_key_id_len);
 
182
        }
166
183
 
167
184
 
168
185
      if (pkey_key_id)
169
 
        {
170
 
          free (pkey_key_id);
171
 
          pkey_key_id = NULL;
172
 
        }
 
186
        {
 
187
          free (pkey_key_id);
 
188
          pkey_key_id = NULL;
 
189
        }
173
190
 
174
191
      if (crq_key_id)
175
 
        {
176
 
          free (crq_key_id);
177
 
          crq_key_id = NULL;
178
 
        }
 
192
        {
 
193
          free (crq_key_id);
 
194
          crq_key_id = NULL;
 
195
        }
179
196
 
180
197
      gnutls_x509_crq_deinit (crq);
181
198
      gnutls_x509_privkey_deinit (pkey);
 
199
      gnutls_privkey_deinit (abs_pkey);
182
200
    }
183
201
 
184
202
  gnutls_global_deinit ();