← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/auth_rsa.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:
lib/auth_rsa.c
44
44
#include <gnutls_mpi.h>
45
45
 
46
46
int _gnutls_gen_rsa_client_kx (gnutls_session_t, opaque **);
47
 
int _gnutls_proc_rsa_client_kx (gnutls_session_t, opaque *, size_t);
 
47
static int proc_rsa_client_kx (gnutls_session_t, opaque *, size_t);
48
48
 
49
49
const mod_auth_st rsa_auth_struct = {
50
50
  "RSA",
51
51
  _gnutls_gen_cert_server_certificate,
52
52
  _gnutls_gen_cert_client_certificate,
53
 
  NULL,                         /* gen server kx */
 
53
  NULL,                         /* gen server kx */
54
54
  _gnutls_gen_rsa_client_kx,
55
 
  _gnutls_gen_cert_client_cert_vrfy,    /* gen client cert vrfy */
56
 
  _gnutls_gen_cert_server_cert_req,     /* server cert request */
 
55
  _gnutls_gen_cert_client_cert_vrfy,    /* gen client cert vrfy */
 
56
  _gnutls_gen_cert_server_cert_req,     /* server cert request */
57
57
 
58
58
  _gnutls_proc_cert_server_certificate,
59
59
  _gnutls_proc_cert_client_certificate,
60
 
  NULL,                         /* proc server kx */
61
 
  _gnutls_proc_rsa_client_kx,   /* proc client kx */
62
 
  _gnutls_proc_cert_client_cert_vrfy,   /* proc client cert vrfy */
63
 
  _gnutls_proc_cert_cert_req    /* proc server cert request */
 
60
  NULL,                         /* proc server kx */
 
61
  proc_rsa_client_kx,           /* proc client kx */
 
62
  _gnutls_proc_cert_client_cert_vrfy,   /* proc client cert vrfy */
 
63
  _gnutls_proc_cert_cert_req    /* proc server cert request */
64
64
};
65
65
 
66
66
/* This function reads the RSA parameters from peer's certificate;
67
67
 */
68
68
static int
69
69
_gnutls_get_public_rsa_params (gnutls_session_t session,
70
 
                               bigint_t params[MAX_PUBLIC_PARAMS_SIZE],
71
 
                               int *params_len)
 
70
                               bigint_t params[MAX_PUBLIC_PARAMS_SIZE],
 
71
                               int *params_len)
72
72
{
73
73
  int ret;
74
74
  cert_auth_info_t info;
87
87
 
88
88
  ret =
89
89
    _gnutls_get_auth_info_gcert (&peer_cert,
90
 
                                 session->security_parameters.cert_type,
91
 
                                 info, CERT_ONLY_PUBKEY | CERT_NO_COPY);
 
90
                                 session->security_parameters.cert_type,
 
91
                                 info, CERT_ONLY_PUBKEY | CERT_NO_COPY);
92
92
 
93
93
  if (ret < 0)
94
94
    {
107
107
      _gnutls_gcert_deinit (&peer_cert);
108
108
 
109
109
      if (session->key->rsa[0] == NULL || session->key->rsa[1] == NULL)
110
 
        {
111
 
          gnutls_assert ();
112
 
          return GNUTLS_E_INTERNAL_ERROR;
113
 
        }
 
110
        {
 
111
          gnutls_assert ();
 
112
          return GNUTLS_E_INTERNAL_ERROR;
 
113
        }
114
114
 
115
115
      if (*params_len < 2)
116
 
        {
117
 
          gnutls_assert ();
118
 
          return GNUTLS_E_INTERNAL_ERROR;
119
 
        }
 
116
        {
 
117
          gnutls_assert ();
 
118
          return GNUTLS_E_INTERNAL_ERROR;
 
119
        }
120
120
      *params_len = 2;
121
121
      for (i = 0; i < *params_len; i++)
122
 
        {
123
 
          params[i] = _gnutls_mpi_copy (session->key->rsa[i]);
124
 
        }
 
122
        {
 
123
          params[i] = _gnutls_mpi_copy (session->key->rsa[i]);
 
124
        }
125
125
 
126
126
      return 0;
127
127
    }
144
144
  return 0;
145
145
}
146
146
 
147
 
/* This function reads the RSA parameters from the private key
148
 
 */
149
147
static int
150
 
_gnutls_get_private_rsa_params (gnutls_session_t session,
151
 
                                bigint_t ** params, int *params_size)
152
 
{
153
 
  int bits;
154
 
  gnutls_certificate_credentials_t cred;
155
 
  gnutls_rsa_params_t rsa_params;
156
 
 
157
 
  cred = (gnutls_certificate_credentials_t)
158
 
    _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
159
 
  if (cred == NULL)
160
 
    {
161
 
      gnutls_assert ();
162
 
      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
163
 
    }
164
 
 
165
 
  if (session->internals.selected_cert_list == NULL)
166
 
    {
167
 
      gnutls_assert ();
168
 
      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
169
 
    }
170
 
 
171
 
  bits =
172
 
    _gnutls_mpi_get_nbits (session->internals.
173
 
                           selected_cert_list[0].params[0]);
174
 
 
175
 
  if (_gnutls_cipher_suite_get_kx_algo
176
 
      (&session->security_parameters.current_cipher_suite)
177
 
      == GNUTLS_KX_RSA_EXPORT && bits > 512)
178
 
    {
179
 
 
180
 
      rsa_params =
181
 
        _gnutls_certificate_get_rsa_params (cred->rsa_params,
182
 
                                            cred->params_func, session);
183
 
      /* EXPORT case: */
184
 
      if (rsa_params == NULL)
185
 
        {
186
 
          gnutls_assert ();
187
 
          return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
188
 
        }
189
 
 
190
 
      /* In the export case, we do use temporary RSA params
191
 
       * of 512 bits size. The params in the certificate are
192
 
       * used to sign this temporary stuff.
193
 
       */
194
 
      *params_size = RSA_PRIVATE_PARAMS;
195
 
      *params = rsa_params->params;
196
 
 
197
 
      return 0;
198
 
    }
199
 
 
200
 
  /* non export cipher suites. */
201
 
 
202
 
  *params_size = session->internals.selected_key->params_size;
203
 
  *params = session->internals.selected_key->params;
204
 
 
205
 
  return 0;
206
 
}
207
 
 
208
 
int
209
 
_gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
210
 
                            size_t _data_size)
 
148
proc_rsa_client_kx (gnutls_session_t session, opaque * data,
 
149
                    size_t _data_size)
211
150
{
212
151
  gnutls_datum_t plaintext;
213
152
  gnutls_datum_t ciphertext;
214
153
  int ret, dsize;
215
 
  bigint_t *params;
216
 
  int params_len;
217
154
  int randomize_key = 0;
218
155
  ssize_t data_size = _data_size;
219
156
 
233
170
      dsize = _gnutls_read_uint16 (data);
234
171
 
235
172
      if (dsize != data_size)
236
 
        {
237
 
          gnutls_assert ();
238
 
          return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
239
 
        }
 
173
        {
 
174
          gnutls_assert ();
 
175
          return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
 
176
        }
240
177
      ciphertext.size = dsize;
241
178
    }
242
179
 
243
 
  ret = _gnutls_get_private_rsa_params (session, &params, &params_len);
244
 
  if (ret < 0)
245
 
    {
246
 
      gnutls_assert ();
247
 
      return ret;
248
 
    }
249
 
 
250
 
  ret = _gnutls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2);     /* btype==2 */
 
180
  ret =
 
181
    gnutls_privkey_decrypt_data (session->internals.selected_key, 0,
 
182
                                 &ciphertext, &plaintext);
251
183
 
252
184
  if (ret < 0 || plaintext.size != GNUTLS_MASTER_SIZE)
253
185
    {
265
197
       * check the version number.
266
198
       */
267
199
      if (_gnutls_get_adv_version_major (session) != plaintext.data[0]
268
 
          || _gnutls_get_adv_version_minor (session) != plaintext.data[1])
269
 
        {
270
 
          /* No error is returned here, if the version number check
271
 
           * fails. We proceed normally.
272
 
           * That is to defend against the attack described in the paper
273
 
           * "Attacking RSA-based sessions in SSL/TLS" by Vlastimil Klima,
274
 
           * Ondej Pokorny and Tomas Rosa.
275
 
           */
276
 
          gnutls_assert ();
277
 
          _gnutls_x509_log
278
 
            ("auth_rsa: Possible PKCS #1 version check format attack\n");
279
 
        }
 
200
          || _gnutls_get_adv_version_minor (session) != plaintext.data[1])
 
201
        {
 
202
          /* No error is returned here, if the version number check
 
203
           * fails. We proceed normally.
 
204
           * That is to defend against the attack described in the paper
 
205
           * "Attacking RSA-based sessions in SSL/TLS" by Vlastimil Klima,
 
206
           * Ondej Pokorny and Tomas Rosa.
 
207
           */
 
208
          gnutls_assert ();
 
209
          _gnutls_x509_log
 
210
            ("auth_rsa: Possible PKCS #1 version check format attack\n");
 
211
        }
280
212
    }
281
213
 
282
214
  if (randomize_key != 0)
284
216
      session->key->key.size = GNUTLS_MASTER_SIZE;
285
217
      session->key->key.data = gnutls_malloc (session->key->key.size);
286
218
      if (session->key->key.data == NULL)
287
 
        {
288
 
          gnutls_assert ();
289
 
          return GNUTLS_E_MEMORY_ERROR;
290
 
        }
 
219
        {
 
220
          gnutls_assert ();
 
221
          return GNUTLS_E_MEMORY_ERROR;
 
222
        }
291
223
 
292
224
      /* we do not need strong random numbers here.
293
225
       */
294
226
      ret = _gnutls_rnd (GNUTLS_RND_NONCE, session->key->key.data,
295
 
                         session->key->key.size);
 
227
                         session->key->key.size);
296
228
      if (ret < 0)
297
 
        {
298
 
          gnutls_assert ();
299
 
          return ret;
300
 
        }
 
229
        {
 
230
          gnutls_assert ();
 
231
          return ret;
 
232
        }
301
233
 
302
234
    }
303
235
  else
323
255
_gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
324
256
{
325
257
  cert_auth_info_t auth = session->key->auth_info;
326
 
  gnutls_datum_t sdata;         /* data to send */
 
258
  gnutls_datum_t sdata;         /* data to send */
327
259
  bigint_t params[MAX_PUBLIC_PARAMS_SIZE];
328
260
  int params_len = MAX_PUBLIC_PARAMS_SIZE;
329
261
  int ret, i;
348
280
    }
349
281
 
350
282
  ret = _gnutls_rnd (GNUTLS_RND_RANDOM, session->key->key.data,
351
 
                     session->key->key.size);
 
283
                     session->key->key.size);
352
284
  if (ret < 0)
353
285
    {
354
286
      gnutls_assert ();
363
295
      session->key->key.data[1] = _gnutls_version_get_minor (ver);
364
296
    }
365
297
  else
366
 
    {                           /* use the version provided */
 
298
    {                           /* use the version provided */
367
299
      session->key->key.data[0] = session->internals.rsa_pms_version[0];
368
300
      session->key->key.data[1] = session->internals.rsa_pms_version[1];
369
301
    }
379
311
 
380
312
  if ((ret =
381
313
       _gnutls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
382
 
                                  params, params_len, 2)) < 0)
 
314
                                  params, params_len, 2)) < 0)
383
315
    {
384
316
      gnutls_assert ();
385
317
      return ret;
395
327
      return sdata.size;
396
328
    }
397
329
  else
398
 
    {                           /* TLS 1 */
 
330
    {                           /* TLS 1 */
399
331
      *data = gnutls_malloc (sdata.size + 2);
400
332
      if (*data == NULL)
401
 
        {
402
 
          _gnutls_free_datum (&sdata);
403
 
          return GNUTLS_E_MEMORY_ERROR;
404
 
        }
 
333
        {
 
334
          _gnutls_free_datum (&sdata);
 
335
          return GNUTLS_E_MEMORY_ERROR;
 
336
        }
405
337
      _gnutls_write_datum16 (*data, sdata);
406
338
      ret = sdata.size + 2;
407
339
      _gnutls_free_datum (&sdata);