1 /*
2 * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2004, EdelKey Project. All Rights Reserved.
4 *
5 * Licensed under the Apache License 2.0 (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
9 *
10 * Originally written by Christophe Renou and Peter Sylvester,
11 * for the EdelKey project.
12 */
13
14 /*
15 * We need to use the SRP deprecated APIs in order to implement the SSL SRP
16 * APIs - which are themselves deprecated.
17 */
18 #define OPENSSL_SUPPRESS_DEPRECATED
19
20 #include <openssl/crypto.h>
21 #include <openssl/rand.h>
22 #include <openssl/err.h>
23 #include "ssl_local.h"
24
25 #ifndef OPENSSL_NO_SRP
26 # include <openssl/srp.h>
27
28 /*
29 * The public API SSL_CTX_SRP_CTX_free() is deprecated so we use
30 * ssl_ctx_srp_ctx_free_intern() internally.
31 */
ssl_ctx_srp_ctx_free_intern(SSL_CTX * ctx)32 int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx)
33 {
34 if (ctx == NULL)
35 return 0;
36 OPENSSL_free(ctx->srp_ctx.login);
37 OPENSSL_free(ctx->srp_ctx.info);
38 BN_free(ctx->srp_ctx.N);
39 BN_free(ctx->srp_ctx.g);
40 BN_free(ctx->srp_ctx.s);
41 BN_free(ctx->srp_ctx.B);
42 BN_free(ctx->srp_ctx.A);
43 BN_free(ctx->srp_ctx.a);
44 BN_free(ctx->srp_ctx.b);
45 BN_free(ctx->srp_ctx.v);
46 memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
47 ctx->srp_ctx.strength = SRP_MINIMAL_N;
48 return 1;
49 }
50
SSL_CTX_SRP_CTX_free(SSL_CTX * ctx)51 int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx)
52 {
53 return ssl_ctx_srp_ctx_free_intern(ctx);
54 }
55
56 /*
57 * The public API SSL_SRP_CTX_free() is deprecated so we use
58 * ssl_srp_ctx_free_intern() internally.
59 */
ssl_srp_ctx_free_intern(SSL_CONNECTION * s)60 int ssl_srp_ctx_free_intern(SSL_CONNECTION *s)
61 {
62 if (s == NULL)
63 return 0;
64 OPENSSL_free(s->srp_ctx.login);
65 OPENSSL_free(s->srp_ctx.info);
66 BN_free(s->srp_ctx.N);
67 BN_free(s->srp_ctx.g);
68 BN_free(s->srp_ctx.s);
69 BN_free(s->srp_ctx.B);
70 BN_free(s->srp_ctx.A);
71 BN_free(s->srp_ctx.a);
72 BN_free(s->srp_ctx.b);
73 BN_free(s->srp_ctx.v);
74 memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
75 s->srp_ctx.strength = SRP_MINIMAL_N;
76 return 1;
77 }
78
SSL_SRP_CTX_free(SSL * s)79 int SSL_SRP_CTX_free(SSL *s)
80 {
81 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
82
83 /* the call works with NULL sc */
84 return ssl_srp_ctx_free_intern(sc);
85 }
86
87 /*
88 * The public API SSL_SRP_CTX_init() is deprecated so we use
89 * ssl_srp_ctx_init_intern() internally.
90 */
ssl_srp_ctx_init_intern(SSL_CONNECTION * s)91 int ssl_srp_ctx_init_intern(SSL_CONNECTION *s)
92 {
93 SSL_CTX *ctx;
94
95 if (s == NULL || (ctx = SSL_CONNECTION_GET_CTX(s)) == NULL)
96 return 0;
97
98 memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
99
100 s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;
101 /* set client Hello login callback */
102 s->srp_ctx.TLS_ext_srp_username_callback =
103 ctx->srp_ctx.TLS_ext_srp_username_callback;
104 /* set SRP N/g param callback for verification */
105 s->srp_ctx.SRP_verify_param_callback =
106 ctx->srp_ctx.SRP_verify_param_callback;
107 /* set SRP client passwd callback */
108 s->srp_ctx.SRP_give_srp_client_pwd_callback =
109 ctx->srp_ctx.SRP_give_srp_client_pwd_callback;
110
111 s->srp_ctx.strength = ctx->srp_ctx.strength;
112
113 if (((ctx->srp_ctx.N != NULL) &&
114 ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) ||
115 ((ctx->srp_ctx.g != NULL) &&
116 ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) ||
117 ((ctx->srp_ctx.s != NULL) &&
118 ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) ||
119 ((ctx->srp_ctx.B != NULL) &&
120 ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) ||
121 ((ctx->srp_ctx.A != NULL) &&
122 ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) ||
123 ((ctx->srp_ctx.a != NULL) &&
124 ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) ||
125 ((ctx->srp_ctx.v != NULL) &&
126 ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) ||
127 ((ctx->srp_ctx.b != NULL) &&
128 ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) {
129 ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB);
130 goto err;
131 }
132 if ((ctx->srp_ctx.login != NULL) &&
133 ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) {
134 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
135 goto err;
136 }
137 if ((ctx->srp_ctx.info != NULL) &&
138 ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) {
139 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
140 goto err;
141 }
142 s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;
143
144 return 1;
145 err:
146 OPENSSL_free(s->srp_ctx.login);
147 OPENSSL_free(s->srp_ctx.info);
148 BN_free(s->srp_ctx.N);
149 BN_free(s->srp_ctx.g);
150 BN_free(s->srp_ctx.s);
151 BN_free(s->srp_ctx.B);
152 BN_free(s->srp_ctx.A);
153 BN_free(s->srp_ctx.a);
154 BN_free(s->srp_ctx.b);
155 BN_free(s->srp_ctx.v);
156 memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
157 return 0;
158 }
159
SSL_SRP_CTX_init(SSL * s)160 int SSL_SRP_CTX_init(SSL *s)
161 {
162 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
163
164 /* the call works with NULL sc */
165 return ssl_srp_ctx_init_intern(sc);
166 }
167
168 /*
169 * The public API SSL_CTX_SRP_CTX_init() is deprecated so we use
170 * ssl_ctx_srp_ctx_init_intern() internally.
171 */
ssl_ctx_srp_ctx_init_intern(SSL_CTX * ctx)172 int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx)
173 {
174 if (ctx == NULL)
175 return 0;
176
177 memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx));
178 ctx->srp_ctx.strength = SRP_MINIMAL_N;
179
180 return 1;
181 }
182
SSL_CTX_SRP_CTX_init(SSL_CTX * ctx)183 int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx)
184 {
185 return ssl_ctx_srp_ctx_init_intern(ctx);
186 }
187
188 /* server side */
189 /*
190 * The public API SSL_srp_server_param_with_username() is deprecated so we use
191 * ssl_srp_server_param_with_username_intern() internally.
192 */
ssl_srp_server_param_with_username_intern(SSL_CONNECTION * s,int * ad)193 int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad)
194 {
195 unsigned char b[SSL_MAX_MASTER_KEY_LENGTH];
196 int al;
197 SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
198
199 *ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
200 if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) &&
201 ((al =
202 s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_USER_SSL(s),
203 ad,
204 s->srp_ctx.SRP_cb_arg)) !=
205 SSL_ERROR_NONE))
206 return al;
207
208 *ad = SSL_AD_INTERNAL_ERROR;
209 if ((s->srp_ctx.N == NULL) ||
210 (s->srp_ctx.g == NULL) ||
211 (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL))
212 return SSL3_AL_FATAL;
213
214 if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b),
215 0) <= 0)
216 return SSL3_AL_FATAL;
217 s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL);
218 OPENSSL_cleanse(b, sizeof(b));
219
220 /* Calculate: B = (kv + g^b) % N */
221
222 return ((s->srp_ctx.B =
223 SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
224 s->srp_ctx.v, sctx->libctx, sctx->propq)) !=
225 NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL;
226 }
227
SSL_srp_server_param_with_username(SSL * s,int * ad)228 int SSL_srp_server_param_with_username(SSL *s, int *ad)
229 {
230 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
231
232 if (sc == NULL)
233 return SSL3_AL_FATAL;
234
235 return ssl_srp_server_param_with_username_intern(sc, ad);
236 }
237
238 /*
239 * If the server just has the raw password, make up a verifier entry on the
240 * fly
241 */
SSL_set_srp_server_param_pw(SSL * s,const char * user,const char * pass,const char * grp)242 int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
243 const char *grp)
244 {
245 SRP_gN *GN;
246 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
247
248 if (sc == NULL)
249 return -1;
250
251 GN = SRP_get_default_gN(grp);
252 if (GN == NULL)
253 return -1;
254 sc->srp_ctx.N = BN_dup(GN->N);
255 sc->srp_ctx.g = BN_dup(GN->g);
256 BN_clear_free(sc->srp_ctx.v);
257 sc->srp_ctx.v = NULL;
258 BN_clear_free(sc->srp_ctx.s);
259 sc->srp_ctx.s = NULL;
260 if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v,
261 sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
262 s->ctx->propq))
263 return -1;
264
265 return 1;
266 }
267
SSL_set_srp_server_param(SSL * s,const BIGNUM * N,const BIGNUM * g,BIGNUM * sa,BIGNUM * v,char * info)268 int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
269 BIGNUM *sa, BIGNUM *v, char *info)
270 {
271 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
272
273 if (sc == NULL)
274 return -1;
275
276 if (N != NULL) {
277 if (sc->srp_ctx.N != NULL) {
278 if (!BN_copy(sc->srp_ctx.N, N)) {
279 BN_free(sc->srp_ctx.N);
280 sc->srp_ctx.N = NULL;
281 }
282 } else
283 sc->srp_ctx.N = BN_dup(N);
284 }
285 if (g != NULL) {
286 if (sc->srp_ctx.g != NULL) {
287 if (!BN_copy(sc->srp_ctx.g, g)) {
288 BN_free(sc->srp_ctx.g);
289 sc->srp_ctx.g = NULL;
290 }
291 } else
292 sc->srp_ctx.g = BN_dup(g);
293 }
294 if (sa != NULL) {
295 if (sc->srp_ctx.s != NULL) {
296 if (!BN_copy(sc->srp_ctx.s, sa)) {
297 BN_free(sc->srp_ctx.s);
298 sc->srp_ctx.s = NULL;
299 }
300 } else
301 sc->srp_ctx.s = BN_dup(sa);
302 }
303 if (v != NULL) {
304 if (sc->srp_ctx.v != NULL) {
305 if (!BN_copy(sc->srp_ctx.v, v)) {
306 BN_free(sc->srp_ctx.v);
307 sc->srp_ctx.v = NULL;
308 }
309 } else
310 sc->srp_ctx.v = BN_dup(v);
311 }
312 if (info != NULL) {
313 if (sc->srp_ctx.info)
314 OPENSSL_free(sc->srp_ctx.info);
315 if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL)
316 return -1;
317 }
318
319 if (!(sc->srp_ctx.N) ||
320 !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v))
321 return -1;
322
323 return 1;
324 }
325
srp_generate_server_master_secret(SSL_CONNECTION * s)326 int srp_generate_server_master_secret(SSL_CONNECTION *s)
327 {
328 BIGNUM *K = NULL, *u = NULL;
329 int ret = 0, tmp_len = 0;
330 unsigned char *tmp = NULL;
331 SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
332
333 if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N))
334 goto err;
335 if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
336 sctx->libctx, sctx->propq)) == NULL)
337 goto err;
338 if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b,
339 s->srp_ctx.N)) == NULL)
340 goto err;
341
342 tmp_len = BN_num_bytes(K);
343 if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
344 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
345 goto err;
346 }
347 BN_bn2bin(K, tmp);
348 /* Calls SSLfatal() as required */
349 ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
350 err:
351 BN_clear_free(K);
352 BN_clear_free(u);
353 return ret;
354 }
355
356 /* client side */
srp_generate_client_master_secret(SSL_CONNECTION * s)357 int srp_generate_client_master_secret(SSL_CONNECTION *s)
358 {
359 BIGNUM *x = NULL, *u = NULL, *K = NULL;
360 int ret = 0, tmp_len = 0;
361 char *passwd = NULL;
362 unsigned char *tmp = NULL;
363 SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
364
365 /*
366 * Checks if b % n == 0
367 */
368 if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0
369 || (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
370 sctx->libctx, sctx->propq))
371 == NULL
372 || s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
373 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
374 goto err;
375 }
376 if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_USER_SSL(s),
377 s->srp_ctx.SRP_cb_arg))
378 == NULL) {
379 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
380 goto err;
381 }
382 if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd,
383 sctx->libctx, sctx->propq)) == NULL
384 || (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
385 s->srp_ctx.g, x,
386 s->srp_ctx.a, u,
387 sctx->libctx,
388 sctx->propq)) == NULL) {
389 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
390 goto err;
391 }
392
393 tmp_len = BN_num_bytes(K);
394 if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
395 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
396 goto err;
397 }
398 BN_bn2bin(K, tmp);
399 /* Calls SSLfatal() as required */
400 ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
401 err:
402 BN_clear_free(K);
403 BN_clear_free(x);
404 if (passwd != NULL)
405 OPENSSL_clear_free(passwd, strlen(passwd));
406 BN_clear_free(u);
407 return ret;
408 }
409
srp_verify_server_param(SSL_CONNECTION * s)410 int srp_verify_server_param(SSL_CONNECTION *s)
411 {
412 SRP_CTX *srp = &s->srp_ctx;
413 /*
414 * Sanity check parameters: we can quickly check B % N == 0 by checking B
415 * != 0 since B < N
416 */
417 if (BN_ucmp(srp->g, srp->N) >= 0 || BN_ucmp(srp->B, srp->N) >= 0
418 || BN_is_zero(srp->B)) {
419 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DATA);
420 return 0;
421 }
422
423 if (BN_num_bits(srp->N) < srp->strength) {
424 SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY);
425 return 0;
426 }
427
428 if (srp->SRP_verify_param_callback) {
429 if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_USER_SSL(s),
430 srp->SRP_cb_arg) <= 0) {
431 SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED);
432 return 0;
433 }
434 } else if (!SRP_check_known_gN_param(srp->g, srp->N)) {
435 SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY,
436 SSL_R_INSUFFICIENT_SECURITY);
437 return 0;
438 }
439
440 return 1;
441 }
442
443 /*
444 * The public API SRP_Calc_A_param() is deprecated so we use
445 * ssl_srp_calc_a_param_intern() internally.
446 */
ssl_srp_calc_a_param_intern(SSL_CONNECTION * s)447 int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s)
448 {
449 unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];
450
451 if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
452 rnd, sizeof(rnd), 0) <= 0)
453 return 0;
454 s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a);
455 OPENSSL_cleanse(rnd, sizeof(rnd));
456
457 if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g)))
458 return 0;
459
460 return 1;
461 }
462
SRP_Calc_A_param(SSL * s)463 int SRP_Calc_A_param(SSL *s)
464 {
465 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
466
467 if (sc == NULL)
468 return 0;
469
470 return ssl_srp_calc_a_param_intern(sc);
471 }
472
SSL_get_srp_g(SSL * s)473 BIGNUM *SSL_get_srp_g(SSL *s)
474 {
475 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
476
477 if (sc == NULL)
478 return NULL;
479
480 if (sc->srp_ctx.g != NULL)
481 return sc->srp_ctx.g;
482 return s->ctx->srp_ctx.g;
483 }
484
SSL_get_srp_N(SSL * s)485 BIGNUM *SSL_get_srp_N(SSL *s)
486 {
487 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
488
489 if (sc == NULL)
490 return NULL;
491
492 if (sc->srp_ctx.N != NULL)
493 return sc->srp_ctx.N;
494 return s->ctx->srp_ctx.N;
495 }
496
SSL_get_srp_username(SSL * s)497 char *SSL_get_srp_username(SSL *s)
498 {
499 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
500
501 if (sc == NULL)
502 return NULL;
503
504 if (sc->srp_ctx.login != NULL)
505 return sc->srp_ctx.login;
506 return s->ctx->srp_ctx.login;
507 }
508
SSL_get_srp_userinfo(SSL * s)509 char *SSL_get_srp_userinfo(SSL *s)
510 {
511 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
512
513 if (sc == NULL)
514 return NULL;
515
516 if (sc->srp_ctx.info != NULL)
517 return sc->srp_ctx.info;
518 return s->ctx->srp_ctx.info;
519 }
520
521 # define tls1_ctx_ctrl ssl3_ctx_ctrl
522 # define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl
523
SSL_CTX_set_srp_username(SSL_CTX * ctx,char * name)524 int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name)
525 {
526 return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name);
527 }
528
SSL_CTX_set_srp_password(SSL_CTX * ctx,char * password)529 int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password)
530 {
531 return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password);
532 }
533
SSL_CTX_set_srp_strength(SSL_CTX * ctx,int strength)534 int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
535 {
536 return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
537 NULL);
538 }
539
SSL_CTX_set_srp_verify_param_callback(SSL_CTX * ctx,int (* cb)(SSL *,void *))540 int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
541 int (*cb) (SSL *, void *))
542 {
543 return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB,
544 (void (*)(void))cb);
545 }
546
SSL_CTX_set_srp_cb_arg(SSL_CTX * ctx,void * arg)547 int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg)
548 {
549 return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg);
550 }
551
SSL_CTX_set_srp_username_callback(SSL_CTX * ctx,int (* cb)(SSL *,int *,void *))552 int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
553 int (*cb) (SSL *, int *, void *))
554 {
555 return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB,
556 (void (*)(void))cb);
557 }
558
SSL_CTX_set_srp_client_pwd_callback(SSL_CTX * ctx,char * (* cb)(SSL *,void *))559 int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
560 char *(*cb) (SSL *, void *))
561 {
562 return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB,
563 (void (*)(void))cb);
564 }
565
566 #endif
567
