Branch data Line data Source code
1 : : /* ssl/tls_srp.c */
2 : : /* Written by Christophe Renou (christophe.renou@edelweb.fr) with
3 : : * the precious help of Peter Sylvester (peter.sylvester@edelweb.fr)
4 : : * for the EdelKey project and contributed to the OpenSSL project 2004.
5 : : */
6 : : /* ====================================================================
7 : : * Copyright (c) 2004-2011 The OpenSSL Project. All rights reserved.
8 : : *
9 : : * Redistribution and use in source and binary forms, with or without
10 : : * modification, are permitted provided that the following conditions
11 : : * are met:
12 : : *
13 : : * 1. Redistributions of source code must retain the above copyright
14 : : * notice, this list of conditions and the following disclaimer.
15 : : *
16 : : * 2. Redistributions in binary form must reproduce the above copyright
17 : : * notice, this list of conditions and the following disclaimer in
18 : : * the documentation and/or other materials provided with the
19 : : * distribution.
20 : : *
21 : : * 3. All advertising materials mentioning features or use of this
22 : : * software must display the following acknowledgment:
23 : : * "This product includes software developed by the OpenSSL Project
24 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 : : *
26 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 : : * endorse or promote products derived from this software without
28 : : * prior written permission. For written permission, please contact
29 : : * licensing@OpenSSL.org.
30 : : *
31 : : * 5. Products derived from this software may not be called "OpenSSL"
32 : : * nor may "OpenSSL" appear in their names without prior written
33 : : * permission of the OpenSSL Project.
34 : : *
35 : : * 6. Redistributions of any form whatsoever must retain the following
36 : : * acknowledgment:
37 : : * "This product includes software developed by the OpenSSL Project
38 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 : : *
40 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
52 : : * ====================================================================
53 : : *
54 : : * This product includes cryptographic software written by Eric Young
55 : : * (eay@cryptsoft.com). This product includes software written by Tim
56 : : * Hudson (tjh@cryptsoft.com).
57 : : *
58 : : */
59 : :
60 : : #include <openssl/crypto.h>
61 : : #include <openssl/rand.h>
62 : : #include <openssl/srp.h>
63 : : #include <openssl/err.h>
64 : : #include "ssl_locl.h"
65 : :
66 : : #ifndef OPENSSL_NO_SRP
67 : :
68 : 1808 : int SSL_CTX_SRP_CTX_free(struct ssl_ctx_st *ctx)
69 : : {
70 [ + - ]: 1808 : if (ctx == NULL)
71 : : return 0;
72 : 1808 : OPENSSL_free(ctx->srp_ctx.login);
73 : 1808 : BN_free(ctx->srp_ctx.N);
74 : 1808 : BN_free(ctx->srp_ctx.g);
75 : 1808 : BN_free(ctx->srp_ctx.s);
76 : 1808 : BN_free(ctx->srp_ctx.B);
77 : 1808 : BN_free(ctx->srp_ctx.A);
78 : 1808 : BN_free(ctx->srp_ctx.a);
79 : 1808 : BN_free(ctx->srp_ctx.b);
80 : 1808 : BN_free(ctx->srp_ctx.v);
81 : 1808 : ctx->srp_ctx.TLS_ext_srp_username_callback = NULL;
82 : 1808 : ctx->srp_ctx.SRP_cb_arg = NULL;
83 : 1808 : ctx->srp_ctx.SRP_verify_param_callback = NULL;
84 : 1808 : ctx->srp_ctx.SRP_give_srp_client_pwd_callback = NULL;
85 : 1808 : ctx->srp_ctx.N = NULL;
86 : 1808 : ctx->srp_ctx.g = NULL;
87 : 1808 : ctx->srp_ctx.s = NULL;
88 : 1808 : ctx->srp_ctx.B = NULL;
89 : 1808 : ctx->srp_ctx.A = NULL;
90 : 1808 : ctx->srp_ctx.a = NULL;
91 : 1808 : ctx->srp_ctx.b = NULL;
92 : 1808 : ctx->srp_ctx.v = NULL;
93 : 1808 : ctx->srp_ctx.login = NULL;
94 : 1808 : ctx->srp_ctx.info = NULL;
95 : 1808 : ctx->srp_ctx.strength = SRP_MINIMAL_N;
96 : 1808 : ctx->srp_ctx.srp_Mask = 0;
97 : 1808 : return (1);
98 : : }
99 : :
100 : 1544 : int SSL_SRP_CTX_free(struct ssl_st *s)
101 : : {
102 [ + - ]: 1544 : if (s == NULL)
103 : : return 0;
104 : 1544 : OPENSSL_free(s->srp_ctx.login);
105 : 1544 : BN_free(s->srp_ctx.N);
106 : 1544 : BN_free(s->srp_ctx.g);
107 : 1544 : BN_free(s->srp_ctx.s);
108 : 1544 : BN_free(s->srp_ctx.B);
109 : 1544 : BN_free(s->srp_ctx.A);
110 : 1544 : BN_free(s->srp_ctx.a);
111 : 1544 : BN_free(s->srp_ctx.b);
112 : 1544 : BN_free(s->srp_ctx.v);
113 : 1544 : s->srp_ctx.TLS_ext_srp_username_callback = NULL;
114 : 1544 : s->srp_ctx.SRP_cb_arg = NULL;
115 : 1544 : s->srp_ctx.SRP_verify_param_callback = NULL;
116 : 1544 : s->srp_ctx.SRP_give_srp_client_pwd_callback = NULL;
117 : 1544 : s->srp_ctx.N = NULL;
118 : 1544 : s->srp_ctx.g = NULL;
119 : 1544 : s->srp_ctx.s = NULL;
120 : 1544 : s->srp_ctx.B = NULL;
121 : 1544 : s->srp_ctx.A = NULL;
122 : 1544 : s->srp_ctx.a = NULL;
123 : 1544 : s->srp_ctx.b = NULL;
124 : 1544 : s->srp_ctx.v = NULL;
125 : 1544 : s->srp_ctx.login = NULL;
126 : 1544 : s->srp_ctx.info = NULL;
127 : 1544 : s->srp_ctx.strength = SRP_MINIMAL_N;
128 : 1544 : s->srp_ctx.srp_Mask = 0;
129 : 1544 : return (1);
130 : : }
131 : :
132 : 1544 : int SSL_SRP_CTX_init(struct ssl_st *s)
133 : : {
134 : : SSL_CTX *ctx;
135 : :
136 [ + - ][ + - ]: 1544 : if ((s == NULL) || ((ctx = s->ctx) == NULL))
137 : : return 0;
138 : 1544 : s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;
139 : : /* set client Hello login callback */
140 : 1544 : s->srp_ctx.TLS_ext_srp_username_callback = ctx->srp_ctx.TLS_ext_srp_username_callback;
141 : : /* set SRP N/g param callback for verification */
142 : 1544 : s->srp_ctx.SRP_verify_param_callback = ctx->srp_ctx.SRP_verify_param_callback;
143 : : /* set SRP client passwd callback */
144 : 1544 : s->srp_ctx.SRP_give_srp_client_pwd_callback = ctx->srp_ctx.SRP_give_srp_client_pwd_callback;
145 : :
146 : 1544 : s->srp_ctx.N = NULL;
147 : 1544 : s->srp_ctx.g = NULL;
148 : 1544 : s->srp_ctx.s = NULL;
149 : 1544 : s->srp_ctx.B = NULL;
150 : 1544 : s->srp_ctx.A = NULL;
151 : 1544 : s->srp_ctx.a = NULL;
152 : 1544 : s->srp_ctx.b = NULL;
153 : 1544 : s->srp_ctx.v = NULL;
154 : 1544 : s->srp_ctx.login = NULL;
155 : 1544 : s->srp_ctx.info = ctx->srp_ctx.info;
156 : 1544 : s->srp_ctx.strength = ctx->srp_ctx.strength;
157 : :
158 [ - + # # ]: 1544 : if (((ctx->srp_ctx.N != NULL) &&
159 [ - + ]: 1544 : ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) ||
160 [ # # ]: 0 : ((ctx->srp_ctx.g != NULL) &&
161 [ - + ]: 1544 : ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) ||
162 [ # # ]: 0 : ((ctx->srp_ctx.s != NULL) &&
163 [ - + ]: 1544 : ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) ||
164 [ # # ]: 0 : ((ctx->srp_ctx.B != NULL) &&
165 [ - + ]: 1544 : ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) ||
166 [ # # ]: 0 : ((ctx->srp_ctx.A != NULL) &&
167 [ - + ]: 1544 : ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) ||
168 [ # # ]: 0 : ((ctx->srp_ctx.a != NULL) &&
169 [ - + ]: 1544 : ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) ||
170 [ # # ]: 0 : ((ctx->srp_ctx.v != NULL) &&
171 [ - + ]: 1544 : ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) ||
172 [ # # ]: 0 : ((ctx->srp_ctx.b != NULL) &&
173 : 0 : ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL)))
174 : : {
175 : 0 : SSLerr(SSL_F_SSL_SRP_CTX_INIT,ERR_R_BN_LIB);
176 : 0 : goto err;
177 : : }
178 [ + + - + ]: 1566 : if ((ctx->srp_ctx.login != NULL) &&
179 : 22 : ((s->srp_ctx.login = BUF_strdup(ctx->srp_ctx.login)) == NULL))
180 : : {
181 : 0 : SSLerr(SSL_F_SSL_SRP_CTX_INIT,ERR_R_INTERNAL_ERROR);
182 : 0 : goto err;
183 : : }
184 : 1544 : s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;
185 : :
186 : 1544 : return (1);
187 : : err:
188 : 0 : OPENSSL_free(s->srp_ctx.login);
189 : 0 : BN_free(s->srp_ctx.N);
190 : 0 : BN_free(s->srp_ctx.g);
191 : 0 : BN_free(s->srp_ctx.s);
192 : 0 : BN_free(s->srp_ctx.B);
193 : 0 : BN_free(s->srp_ctx.A);
194 : 0 : BN_free(s->srp_ctx.a);
195 : 0 : BN_free(s->srp_ctx.b);
196 : 0 : BN_free(s->srp_ctx.v);
197 : 0 : return (0);
198 : : }
199 : :
200 : 1808 : int SSL_CTX_SRP_CTX_init(struct ssl_ctx_st *ctx)
201 : : {
202 [ + - ]: 1808 : if (ctx == NULL)
203 : : return 0;
204 : :
205 : 1808 : ctx->srp_ctx.SRP_cb_arg = NULL;
206 : : /* set client Hello login callback */
207 : 1808 : ctx->srp_ctx.TLS_ext_srp_username_callback = NULL;
208 : : /* set SRP N/g param callback for verification */
209 : 1808 : ctx->srp_ctx.SRP_verify_param_callback = NULL;
210 : : /* set SRP client passwd callback */
211 : 1808 : ctx->srp_ctx.SRP_give_srp_client_pwd_callback = NULL;
212 : :
213 : 1808 : ctx->srp_ctx.N = NULL;
214 : 1808 : ctx->srp_ctx.g = NULL;
215 : 1808 : ctx->srp_ctx.s = NULL;
216 : 1808 : ctx->srp_ctx.B = NULL;
217 : 1808 : ctx->srp_ctx.A = NULL;
218 : 1808 : ctx->srp_ctx.a = NULL;
219 : 1808 : ctx->srp_ctx.b = NULL;
220 : 1808 : ctx->srp_ctx.v = NULL;
221 : 1808 : ctx->srp_ctx.login = NULL;
222 : 1808 : ctx->srp_ctx.srp_Mask = 0;
223 : 1808 : ctx->srp_ctx.info = NULL;
224 : 1808 : ctx->srp_ctx.strength = SRP_MINIMAL_N;
225 : :
226 : 1808 : return (1);
227 : : }
228 : :
229 : : /* server side */
230 : 22 : int SSL_srp_server_param_with_username(SSL *s, int *ad)
231 : : {
232 : : unsigned char b[SSL_MAX_MASTER_KEY_LENGTH];
233 : : int al;
234 : :
235 : 22 : *ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
236 [ + - ][ + - ]: 22 : if ((s->srp_ctx.TLS_ext_srp_username_callback !=NULL) &&
237 : 22 : ((al = s->srp_ctx.TLS_ext_srp_username_callback(s, ad, s->srp_ctx.SRP_cb_arg))!=SSL_ERROR_NONE))
238 : : return al;
239 : :
240 : 22 : *ad = SSL_AD_INTERNAL_ERROR;
241 [ + - ][ + - ]: 22 : if ((s->srp_ctx.N == NULL) ||
242 [ + - ]: 22 : (s->srp_ctx.g == NULL) ||
243 [ + - ]: 22 : (s->srp_ctx.s == NULL) ||
244 : 22 : (s->srp_ctx.v == NULL))
245 : : return SSL3_AL_FATAL;
246 : :
247 [ + - ]: 22 : if (RAND_bytes(b, sizeof(b)) <= 0)
248 : : return SSL3_AL_FATAL;
249 : 22 : s->srp_ctx.b = BN_bin2bn(b,sizeof(b),NULL);
250 : 22 : OPENSSL_cleanse(b,sizeof(b));
251 : :
252 : : /* Calculate: B = (kv + g^b) % N */
253 : :
254 : 44 : return ((s->srp_ctx.B = SRP_Calc_B(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g, s->srp_ctx.v)) != NULL)?
255 [ - + ]: 22 : SSL_ERROR_NONE:SSL3_AL_FATAL;
256 : : }
257 : :
258 : : /* If the server just has the raw password, make up a verifier entry on the fly */
259 : 22 : int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass, const char *grp)
260 : : {
261 : 22 : SRP_gN *GN = SRP_get_default_gN(grp);
262 [ + - ]: 22 : if(GN == NULL) return -1;
263 : 22 : s->srp_ctx.N = BN_dup(GN->N);
264 : 22 : s->srp_ctx.g = BN_dup(GN->g);
265 [ - + ]: 22 : if(s->srp_ctx.v != NULL)
266 : : {
267 : 0 : BN_clear_free(s->srp_ctx.v);
268 : 0 : s->srp_ctx.v = NULL;
269 : : }
270 [ - + ]: 22 : if(s->srp_ctx.s != NULL)
271 : : {
272 : 0 : BN_clear_free(s->srp_ctx.s);
273 : 0 : s->srp_ctx.s = NULL;
274 : : }
275 [ + - ]: 22 : if(!SRP_create_verifier_BN(user, pass, &s->srp_ctx.s, &s->srp_ctx.v, GN->N, GN->g)) return -1;
276 : :
277 : 22 : return 1;
278 : : }
279 : :
280 : 0 : int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
281 : : BIGNUM *sa, BIGNUM *v, char *info)
282 : : {
283 [ # # ]: 0 : if (N!= NULL)
284 : : {
285 [ # # ]: 0 : if (s->srp_ctx.N != NULL)
286 : : {
287 [ # # ]: 0 : if (!BN_copy(s->srp_ctx.N,N))
288 : : {
289 : 0 : BN_free(s->srp_ctx.N);
290 : 0 : s->srp_ctx.N = NULL;
291 : : }
292 : : }
293 : : else
294 : 0 : s->srp_ctx.N = BN_dup(N);
295 : : }
296 [ # # ]: 0 : if (g!= NULL)
297 : : {
298 [ # # ]: 0 : if (s->srp_ctx.g != NULL)
299 : : {
300 [ # # ]: 0 : if (!BN_copy(s->srp_ctx.g,g))
301 : : {
302 : 0 : BN_free(s->srp_ctx.g);
303 : 0 : s->srp_ctx.g = NULL;
304 : : }
305 : : }
306 : : else
307 : 0 : s->srp_ctx.g = BN_dup(g);
308 : : }
309 [ # # ]: 0 : if (sa!= NULL)
310 : : {
311 [ # # ]: 0 : if (s->srp_ctx.s != NULL)
312 : : {
313 [ # # ]: 0 : if (!BN_copy(s->srp_ctx.s,sa))
314 : : {
315 : 0 : BN_free(s->srp_ctx.s);
316 : 0 : s->srp_ctx.s = NULL;
317 : : }
318 : : }
319 : : else
320 : 0 : s->srp_ctx.s = BN_dup(sa);
321 : : }
322 [ # # ]: 0 : if (v!= NULL)
323 : : {
324 [ # # ]: 0 : if (s->srp_ctx.v != NULL)
325 : : {
326 [ # # ]: 0 : if (!BN_copy(s->srp_ctx.v,v))
327 : : {
328 : 0 : BN_free(s->srp_ctx.v);
329 : 0 : s->srp_ctx.v = NULL;
330 : : }
331 : : }
332 : : else
333 : 0 : s->srp_ctx.v = BN_dup(v);
334 : : }
335 : 0 : s->srp_ctx.info = info;
336 : :
337 [ # # ][ # # ]: 0 : if (!(s->srp_ctx.N) ||
338 [ # # ]: 0 : !(s->srp_ctx.g) ||
339 [ # # ]: 0 : !(s->srp_ctx.s) ||
340 : 0 : !(s->srp_ctx.v))
341 : : return -1;
342 : :
343 : 0 : return 1;
344 : : }
345 : :
346 : 22 : int SRP_generate_server_master_secret(SSL *s,unsigned char *master_key)
347 : : {
348 : 22 : BIGNUM *K = NULL, *u = NULL;
349 : 22 : int ret = -1, tmp_len;
350 : 22 : unsigned char *tmp = NULL;
351 : :
352 [ + - ]: 22 : if (!SRP_Verify_A_mod_N(s->srp_ctx.A,s->srp_ctx.N))
353 : : goto err;
354 [ + - ]: 22 : if (!(u = SRP_Calc_u(s->srp_ctx.A,s->srp_ctx.B,s->srp_ctx.N)))
355 : : goto err;
356 [ + - ]: 22 : if (!(K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b, s->srp_ctx.N)))
357 : : goto err;
358 : :
359 : 22 : tmp_len = BN_num_bytes(K);
360 [ + - ]: 22 : if ((tmp = OPENSSL_malloc(tmp_len)) == NULL)
361 : : goto err;
362 : 22 : BN_bn2bin(K, tmp);
363 : 22 : ret = s->method->ssl3_enc->generate_master_secret(s,master_key,tmp,tmp_len);
364 : : err:
365 [ + - ]: 22 : if (tmp)
366 : : {
367 : 22 : OPENSSL_cleanse(tmp,tmp_len) ;
368 : 22 : OPENSSL_free(tmp);
369 : : }
370 : 22 : BN_clear_free(K);
371 : 22 : BN_clear_free(u);
372 : 22 : return ret;
373 : : }
374 : :
375 : : /* client side */
376 : 22 : int SRP_generate_client_master_secret(SSL *s,unsigned char *master_key)
377 : : {
378 : 22 : BIGNUM *x = NULL, *u = NULL, *K = NULL;
379 : 22 : int ret = -1, tmp_len;
380 : 22 : char *passwd = NULL;
381 : 22 : unsigned char *tmp = NULL;
382 : :
383 : : /* Checks if b % n == 0
384 : : */
385 [ + - ]: 22 : if (SRP_Verify_B_mod_N(s->srp_ctx.B,s->srp_ctx.N)==0) goto err;
386 [ + - ]: 22 : if (!(u = SRP_Calc_u(s->srp_ctx.A,s->srp_ctx.B,s->srp_ctx.N))) goto err;
387 [ + - ]: 22 : if (s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) goto err;
388 [ + - ]: 22 : if (!(passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(s, s->srp_ctx.SRP_cb_arg))) goto err;
389 [ + - ]: 22 : if (!(x = SRP_Calc_x(s->srp_ctx.s,s->srp_ctx.login,passwd))) goto err;
390 [ + - ]: 22 : if (!(K = SRP_Calc_client_key(s->srp_ctx.N, s->srp_ctx.B, s->srp_ctx.g, x, s->srp_ctx.a, u))) goto err;
391 : :
392 : 22 : tmp_len = BN_num_bytes(K);
393 [ + - ]: 22 : if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) goto err;
394 : 22 : BN_bn2bin(K, tmp);
395 : 22 : ret = s->method->ssl3_enc->generate_master_secret(s,master_key,tmp,tmp_len);
396 : : err:
397 [ + - ]: 22 : if (tmp)
398 : : {
399 : 22 : OPENSSL_cleanse(tmp,tmp_len) ;
400 : 22 : OPENSSL_free(tmp);
401 : : }
402 : 22 : BN_clear_free(K);
403 : 22 : BN_clear_free(x);
404 [ + - ]: 22 : if (passwd)
405 : : {
406 : 22 : OPENSSL_cleanse(passwd,strlen(passwd)) ;
407 : 22 : OPENSSL_free(passwd);
408 : : }
409 : 22 : BN_clear_free(u);
410 : 22 : return ret;
411 : : }
412 : :
413 : 22 : int SRP_Calc_A_param(SSL *s)
414 : : {
415 : : unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];
416 : :
417 [ + - ]: 22 : if (BN_num_bits(s->srp_ctx.N) < s->srp_ctx.strength)
418 : : return 0;
419 : :
420 [ + - + - ]: 44 : if (s->srp_ctx.SRP_verify_param_callback ==NULL &&
421 : 22 : !SRP_check_known_gN_param(s->srp_ctx.g,s->srp_ctx.N))
422 : : return 0;
423 : :
424 [ + - ]: 22 : if (RAND_bytes(rnd, sizeof(rnd)) <= 0)
425 : : return 0;
426 : 22 : s->srp_ctx.a = BN_bin2bn(rnd,sizeof(rnd), s->srp_ctx.a);
427 : 22 : OPENSSL_cleanse(rnd,sizeof(rnd));
428 : :
429 [ + - ]: 22 : if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a,s->srp_ctx.N,s->srp_ctx.g)))
430 : : return 0;
431 : :
432 : : /* We can have a callback to verify SRP param!! */
433 [ - + ]: 22 : if (s->srp_ctx.SRP_verify_param_callback !=NULL)
434 : 0 : return s->srp_ctx.SRP_verify_param_callback(s,s->srp_ctx.SRP_cb_arg);
435 : :
436 : : return 1;
437 : : }
438 : :
439 : 0 : BIGNUM *SSL_get_srp_g(SSL *s)
440 : : {
441 [ # # ]: 0 : if (s->srp_ctx.g != NULL)
442 : : return s->srp_ctx.g;
443 : 0 : return s->ctx->srp_ctx.g;
444 : : }
445 : :
446 : 0 : BIGNUM *SSL_get_srp_N(SSL *s)
447 : : {
448 [ # # ]: 0 : if (s->srp_ctx.N != NULL)
449 : : return s->srp_ctx.N;
450 : 0 : return s->ctx->srp_ctx.N;
451 : : }
452 : :
453 : 22 : char *SSL_get_srp_username(SSL *s)
454 : : {
455 [ - + ]: 22 : if (s->srp_ctx.login != NULL)
456 : : return s->srp_ctx.login;
457 : 0 : return s->ctx->srp_ctx.login;
458 : : }
459 : :
460 : 0 : char *SSL_get_srp_userinfo(SSL *s)
461 : : {
462 [ # # ]: 0 : if (s->srp_ctx.info != NULL)
463 : : return s->srp_ctx.info;
464 : 0 : return s->ctx->srp_ctx.info;
465 : : }
466 : :
467 : : #define tls1_ctx_ctrl ssl3_ctx_ctrl
468 : : #define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl
469 : :
470 : 22 : int SSL_CTX_set_srp_username(SSL_CTX *ctx,char *name)
471 : : {
472 : 22 : return tls1_ctx_ctrl(ctx,SSL_CTRL_SET_TLS_EXT_SRP_USERNAME,0,name);
473 : : }
474 : :
475 : 0 : int SSL_CTX_set_srp_password(SSL_CTX *ctx,char *password)
476 : : {
477 : 0 : return tls1_ctx_ctrl(ctx,SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD,0,password);
478 : : }
479 : :
480 : 0 : int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
481 : : {
482 : 0 : return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
483 : : NULL);
484 : : }
485 : :
486 : 0 : int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx, int (*cb)(SSL *,void *))
487 : : {
488 : 0 : return tls1_ctx_callback_ctrl(ctx,SSL_CTRL_SET_SRP_VERIFY_PARAM_CB,
489 : : (void (*)(void))cb);
490 : : }
491 : :
492 : 44 : int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg)
493 : : {
494 : 44 : return tls1_ctx_ctrl(ctx,SSL_CTRL_SET_SRP_ARG,0,arg);
495 : : }
496 : :
497 : 22 : int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
498 : : int (*cb)(SSL *,int *,void *))
499 : : {
500 : 22 : return tls1_ctx_callback_ctrl(ctx,SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB,
501 : : (void (*)(void))cb);
502 : : }
503 : :
504 : 22 : int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx, char *(*cb)(SSL *,void *))
505 : : {
506 : 22 : return tls1_ctx_callback_ctrl(ctx,SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB,
507 : : (void (*)(void))cb);
508 : : }
509 : :
510 : : #endif
|
