← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnutls26/trusty

« back to all changes in this revision

Viewing changes to lib/auth_dhe_psk.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
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_dhe_psk.c
55
55
  NULL,
56
56
 
57
57
  NULL,
58
 
  NULL,                         /* certificate */
 
58
  NULL,                         /* certificate */
59
59
  proc_psk_server_kx,
60
60
  proc_psk_client_kx,
61
61
  NULL,
65
65
static int
66
66
gen_psk_client_kx (gnutls_session_t session, opaque ** data)
67
67
{
68
 
  int ret;
 
68
  int ret, free;
69
69
  opaque *tmp_data = NULL;
70
70
  int data_size, tmp_data_size;
71
71
  gnutls_psk_client_credentials_t cred;
 
72
  gnutls_datum_t username, key;
72
73
 
73
74
  cred = (gnutls_psk_client_credentials_t)
74
75
    _gnutls_get_cred (session->key, GNUTLS_CRD_PSK, NULL);
75
76
 
76
77
  if (cred == NULL)
77
 
    {
78
 
      gnutls_assert ();
79
 
      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
80
 
    }
81
 
 
82
 
  if (cred->username.data == NULL || cred->key.data == NULL)
83
 
    {
84
 
      gnutls_assert ();
85
 
      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
86
 
    }
 
78
    return gnutls_assert_val(GNUTLS_E_INSUFFICIENT_CREDENTIALS);
 
79
 
 
80
 
 
81
  ret = _gnutls_find_psk_key( session, cred, &username, &key, &free);
 
82
  if (ret < 0)
 
83
    return gnutls_assert_val(ret);
87
84
 
88
85
  /* The PSK key is set in there */
89
 
  ret = _gnutls_gen_dh_common_client_kx (session, &tmp_data);
 
86
  ret = _gnutls_gen_dh_common_client_kx_int (session, &tmp_data, &key);
90
87
  if (ret < 0)
91
88
    {
92
89
      gnutls_assert ();
93
 
      return ret;
 
90
      goto cleanup;
94
91
    }
95
92
 
96
93
  tmp_data_size = ret;
97
 
  data_size = tmp_data_size + cred->username.size + 2;
 
94
  data_size = tmp_data_size + username.size + 2;
98
95
 
99
96
  (*data) = gnutls_malloc (data_size);
100
97
  if ((*data) == NULL)
101
98
    {
102
99
      gnutls_assert ();
103
100
      ret = GNUTLS_E_MEMORY_ERROR;
104
 
      goto error;
 
101
      goto cleanup;
105
102
    }
106
103
 
107
 
  _gnutls_write_datum16 (*data, cred->username);
108
 
  memcpy (&(*data)[cred->username.size + 2], tmp_data, tmp_data_size);
 
104
  _gnutls_write_datum16 (*data, username);
 
105
  memcpy (&(*data)[username.size + 2], tmp_data, tmp_data_size);
109
106
 
110
107
  ret = data_size;
111
108
 
112
 
error:
 
109
cleanup:
113
110
  gnutls_free (tmp_data);
 
111
  if (free)
 
112
    {
 
113
      _gnutls_free_datum(&username);
 
114
      _gnutls_free_datum(&key);
 
115
    }
 
116
 
114
117
  return ret;
115
118
 
116
119
}
146
149
 
147
150
  if ((ret =
148
151
       _gnutls_auth_info_set (session, GNUTLS_CRD_PSK,
149
 
                              sizeof (psk_auth_info_st), 1)) < 0)
 
152
                              sizeof (psk_auth_info_st), 1)) < 0)
150
153
    {
151
154
      gnutls_assert ();
152
155
      return ret;
166
169
 
167
170
static int
168
171
proc_psk_client_kx (gnutls_session_t session, opaque * data,
169
 
                    size_t _data_size)
 
172
                    size_t _data_size)
170
173
{
171
174
  int ret;
172
175
  bigint_t p, g;
188
191
 
189
192
  if ((ret =
190
193
       _gnutls_auth_info_set (session, GNUTLS_CRD_PSK,
191
 
                              sizeof (psk_auth_info_st), 1)) < 0)
 
194
                              sizeof (psk_auth_info_st), 1)) < 0)
192
195
    {
193
196
      gnutls_assert ();
194
197
      return ret;
217
220
   */
218
221
  info = _gnutls_get_auth_info (session);
219
222
 
220
 
  if (username.size > MAX_SRP_USERNAME)
 
223
  if (username.size > MAX_USERNAME_SIZE)
221
224
    {
222
225
      gnutls_assert ();
223
226
      return GNUTLS_E_ILLEGAL_SRP_USERNAME;
237
240
 
238
241
int
239
242
proc_psk_server_kx (gnutls_session_t session, opaque * data,
240
 
                    size_t _data_size)
 
243
                    size_t _data_size)
241
244
{
242
245
 
243
246
  int ret;
245
248
  /* set auth_info */
246
249
  if ((ret =
247
250
       _gnutls_auth_info_set (session, GNUTLS_CRD_PSK,
248
 
                              sizeof (psk_auth_info_st), 1)) < 0)
 
251
                              sizeof (psk_auth_info_st), 1)) < 0)
249
252
    {
250
253
      gnutls_assert ();
251
254
      return ret;