?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / lib / sasl_plugins / gssapi / gssapi.c
blob2b03caf706586883ffe65f2b2cb6c7805c2f181e
1 /*
2 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /* GSSAPI SASL plugin
7 * Leif Johansson
8 * Rob Siemborski (SASL v2 Conversion)
9 * $Id: gssapi.c,v 1.75 2003/07/02 13:13:42 rjs3 Exp $
10 */
11 /*
12 * Copyright (c) 1998-2003 Carnegie Mellon University. All rights reserved.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 *
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 *
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in
23 * the documentation and/or other materials provided with the
24 * distribution.
25 *
26 * 3. The name "Carnegie Mellon University" must not be used to
27 * endorse or promote products derived from this software without
28 * prior written permission. For permission or any other legal
29 * details, please contact
30 * Office of Technology Transfer
31 * Carnegie Mellon University
32 * 5000 Forbes Avenue
33 * Pittsburgh, PA 15213-3890
34 * (412) 268-4387, fax: (412) 268-7395
35 * tech-transfer@andrew.cmu.edu
36 *
37 * 4. Redistributions of any form whatsoever must retain the following
38 * acknowledgment:
39 * "This product includes software developed by Computing Services
40 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
41 *
42 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
43 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
44 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
45 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
46 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
47 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
48 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
49 */
50
51 #include <config.h>
52
53 #ifdef HAVE_GSSAPI_H
54 #include <gssapi.h>
55 #else
56 #include <gssapi/gssapi.h>
57 #endif
58
59 #ifdef WIN32
60 # include <winsock.h>
61
62 # ifndef R_OK
63 # define R_OK 04
64 # endif
65 /* we also need io.h for access() prototype */
66 # include <io.h>
67 #else
68 # include <sys/param.h>
69 # include <sys/socket.h>
70 # include <netinet/in.h>
71 # include <arpa/inet.h>
72 # include <netdb.h>
73 #endif /* WIN32 */
74 #include <fcntl.h>
75 #include <stdio.h>
76 #include <sasl.h>
77 #include <saslutil.h>
78 #include <saslplug.h>
79
80 #include "plugin_common.h"
81
82 #ifdef HAVE_UNISTD_H
83 #include <unistd.h>
84 #endif
85
86 #include <errno.h>
87
88 #ifdef WIN32
89 /* This must be after sasl.h */
90 # include "saslgssapi.h"
91 #endif /* WIN32 */
92
93 /***************************** Common Section *****************************/
94
95 #ifndef _SUN_SDK_
96 static const char plugin_id[] = "$Id: gssapi.c,v 1.75 2003/07/02 13:13:42 rjs3 Exp $";
97 #endif /* !_SUN_SDK_ */
98
99 static const char * GSSAPI_BLANK_STRING = "";
100
101 #ifndef HAVE_GSS_C_NT_HOSTBASED_SERVICE
102 extern gss_OID gss_nt_service_name;
103 #define GSS_C_NT_HOSTBASED_SERVICE gss_nt_service_name
104 #endif
105
106 #ifdef _SUN_SDK_
107 static int
108 get_oid(const sasl_utils_t *utils, gss_OID *oid);
109 #ifdef GSSAPI_PROTECT
110 DEFINE_STATIC_MUTEX(global_mutex);
111 #endif /* GSSAPI_PROTECT */
112 #endif /* _SUN_SDK_ */
113
114 /* GSSAPI SASL Mechanism by Leif Johansson <leifj@matematik.su.se>
115 * inspired by the kerberos mechanism and the gssapi_server and
116 * gssapi_client from the heimdal distribution by Assar Westerlund
117 * <assar@sics.se> and Johan Danielsson <joda@pdc.kth.se>.
118 * See the configure.in file for details on dependencies.
119 * Heimdal can be obtained from http://www.pdc.kth.se/heimdal
120 *
121 * Important contributions from Sam Hartman <hartmans@fundsxpress.com>.
122 */
123
124 typedef struct context {
125 int state;
126
127 gss_ctx_id_t gss_ctx;
128 gss_name_t client_name;
129 gss_name_t server_name;
130 gss_cred_id_t server_creds;
131 sasl_ssf_t limitssf, requiressf; /* application defined bounds, for the
132 server */
133 #ifdef _SUN_SDK_
134 gss_cred_id_t client_creds;
135 gss_OID mech_oid;
136 int use_authid;
137 #endif /* _SUN_SDK_ */
138 const sasl_utils_t *utils;
139
140 /* layers buffering */
141 char *buffer;
142 #ifdef _SUN_SDK_
143 unsigned bufsize;
144 #else
145 int bufsize;
146 #endif /* _SUN_SDK_ */
147 char sizebuf[4];
148 #ifdef _SUN_SDK_
149 unsigned cursize;
150 unsigned size;
151 #else
152 int cursize;
153 int size;
154 #endif /* _SUN_SDK_ */
155 unsigned needsize;
156
157 char *encode_buf; /* For encoding/decoding mem management */
158 char *decode_buf;
159 char *decode_once_buf;
160 unsigned encode_buf_len;
161 unsigned decode_buf_len;
162 unsigned decode_once_buf_len;
163 buffer_info_t *enc_in_buf;
164
165 char *out_buf; /* per-step mem management */
166 unsigned out_buf_len;
167
168 char *authid; /* hold the authid between steps - server */
169 const char *user; /* hold the userid between steps - client */
170 #ifdef _SUN_SDK_
171 const char *client_authid;
172 #endif /* _SUN_SDK_ */
173 #ifdef _INTEGRATED_SOLARIS_
174 void *h;
175 #endif /* _INTEGRATED_SOLARIS_ */
176 } context_t;
177
178 enum {
179 SASL_GSSAPI_STATE_AUTHNEG = 1,
180 SASL_GSSAPI_STATE_SSFCAP = 2,
181 SASL_GSSAPI_STATE_SSFREQ = 3,
182 SASL_GSSAPI_STATE_AUTHENTICATED = 4
183 };
184
185 #ifdef _SUN_SDK_
186 /* sasl_gss_log only logs gss_display_status() error string */
187 #define sasl_gss_log(x,y,z) sasl_gss_seterror_(text,y,z,1)
188 #define sasl_gss_seterror(x,y,z) sasl_gss_seterror_(text,y,z,0)
189 static void
190 sasl_gss_seterror_(const context_t *text, OM_uint32 maj, OM_uint32 min,
191 int logonly)
192 #else
193 static void
194 sasl_gss_seterror(const sasl_utils_t *utils, OM_uint32 maj, OM_uint32 min)
195 #endif /* _SUN_SDK_ */
196 {
197 OM_uint32 maj_stat, min_stat;
198 gss_buffer_desc msg;
199 OM_uint32 msg_ctx;
200 int ret;
201 char *out = NULL;
202 #ifdef _SUN_SDK_
203 unsigned len, curlen = 0;
204 const sasl_utils_t *utils = text->utils;
205 char *prefix = dgettext(TEXT_DOMAIN, "GSSAPI Error: ");
206 #else
207 size_t len, curlen = 0;
208 const char prefix[] = "GSSAPI Error: ";
209 #endif /* _SUN_SDK_ */
210
211 if(!utils) return;
212
213 len = sizeof(prefix);
214 ret = _plug_buf_alloc(utils, &out, &curlen, 256);
215 if(ret != SASL_OK) return;
216
217 strcpy(out, prefix);
218
219 msg_ctx = 0;
220 while (1) {
221 maj_stat = gss_display_status(&min_stat, maj,
222 #ifdef _SUN_SDK_
223 GSS_C_GSS_CODE, text->mech_oid,
224 #else
225 GSS_C_GSS_CODE, GSS_C_NULL_OID,
226 #endif /* _SUN_SDK_ */
227 &msg_ctx, &msg);
228 if(GSS_ERROR(maj_stat)) {
229 #ifdef _SUN_SDK_
230 if (logonly) {
231 utils->log(text->utils->conn, SASL_LOG_FAIL,
232 "GSSAPI Failure: (could not get major error message)");
233 } else {
234 #endif /* _SUN_SDK_ */
235 #ifdef _INTEGRATED_SOLARIS_
236 utils->seterror(utils->conn, 0,
237 gettext("GSSAPI Failure "
238 "(could not get major error message)"));
239 #ifdef _SUN_SDK_
240 }
241 #endif /* _SUN_SDK_ */
242 #else
243 utils->seterror(utils->conn, 0,
244 "GSSAPI Failure "
245 "(could not get major error message)");
246 #ifdef _SUN_SDK_
247 }
248 #endif /* _SUN_SDK_ */
249 #endif /* _INTEGRATED_SOLARIS_ */
250 utils->free(out);
251 return;
252 }
253
254 len += len + msg.length;
255 ret = _plug_buf_alloc(utils, &out, &curlen, len);
256
257 if(ret != SASL_OK) {
258 utils->free(out);
259 return;
260 }
261
262 strcat(out, msg.value);
263
264 gss_release_buffer(&min_stat, &msg);
265
266 if (!msg_ctx)
267 break;
268 }
269
270 /* Now get the minor status */
271
272 len += 2;
273 ret = _plug_buf_alloc(utils, &out, &curlen, len);
274 if(ret != SASL_OK) {
275 utils->free(out);
276 return;
277 }
278
279 strcat(out, " (");
280
281 msg_ctx = 0;
282 while (1) {
283 maj_stat = gss_display_status(&min_stat, min,
284 #ifdef _SUN_SDK_
285 GSS_C_MECH_CODE, text->mech_oid,
286 #else
287 GSS_C_MECH_CODE, GSS_C_NULL_OID,
288 #endif /* _SUN_SDK_ */
289 &msg_ctx, &msg);
290 if(GSS_ERROR(maj_stat)) {
291 #ifdef _SUN_SDK_
292 if (logonly) {
293 utils->log(text->utils->conn, SASL_LOG_FAIL,
294 "GSSAPI Failure: (could not get minor error message)");
295 } else {
296 #endif /* _SUN_SDK_ */
297 #ifdef _INTEGRATED_SOLARIS_
298 utils->seterror(utils->conn, 0,
299 gettext("GSSAPI Failure "
300 "(could not get minor error message)"));
301 #ifdef _SUN_SDK_
302 }
303 #endif /* _SUN_SDK_ */
304 #else
305 utils->seterror(utils->conn, 0,
306 "GSSAPI Failure "
307 "(could not get minor error message)");
308 #ifdef _SUN_SDK_
309 }
310 #endif /* _SUN_SDK_ */
311 #endif /* _INTEGRATED_SOLARIS_ */
312 utils->free(out);
313 return;
314 }
315
316 len += len + msg.length;
317 ret = _plug_buf_alloc(utils, &out, &curlen, len);
318
319 if(ret != SASL_OK) {
320 utils->free(out);
321 return;
322 }
323
324 strcat(out, msg.value);
325
326 gss_release_buffer(&min_stat, &msg);
327
328 if (!msg_ctx)
329 break;
330 }
331
332 len += 1;
333 ret = _plug_buf_alloc(utils, &out, &curlen, len);
334 if(ret != SASL_OK) {
335 utils->free(out);
336 return;
337 }
338
339 strcat(out, ")");
340
341 #ifdef _SUN_SDK_
342 if (logonly) {
343 utils->log(text->utils->conn, SASL_LOG_FAIL, out);
344 } else {
345 utils->seterror(utils->conn, 0, out);
346 }
347 #else
348 utils->seterror(utils->conn, 0, out);
349 #endif /* _SUN_SDK_ */
350 utils->free(out);
351 }
352
353 static int
354 sasl_gss_encode(void *context, const struct iovec *invec, unsigned numiov,
355 const char **output, unsigned *outputlen, int privacy)
356 {
357 context_t *text = (context_t *)context;
358 OM_uint32 maj_stat, min_stat;
359 gss_buffer_t input_token, output_token;
360 gss_buffer_desc real_input_token, real_output_token;
361 int ret;
362 struct buffer_info *inblob, bufinfo;
363
364 if(!output) return SASL_BADPARAM;
365
366 if(numiov > 1) {
367 ret = _plug_iovec_to_buf(text->utils, invec, numiov, &text->enc_in_buf);
368 if(ret != SASL_OK) return ret;
369 inblob = text->enc_in_buf;
370 } else {
371 bufinfo.data = invec[0].iov_base;
372 bufinfo.curlen = invec[0].iov_len;
373 inblob = &bufinfo;
374 }
375
376 if (text->state != SASL_GSSAPI_STATE_AUTHENTICATED) return SASL_NOTDONE;
377
378 input_token = &real_input_token;
379
380 real_input_token.value = inblob->data;
381 real_input_token.length = inblob->curlen;
382
383 output_token = &real_output_token;
384 output_token->value = NULL;
385 output_token->length = 0;
386
387 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
388 if (LOCK_MUTEX(&global_mutex) < 0)
389 return (SASL_FAIL);
390 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
391 maj_stat = gss_wrap (&min_stat,
392 text->gss_ctx,
393 privacy,
394 GSS_C_QOP_DEFAULT,
395 input_token,
396 NULL,
397 output_token);
398
399 if (GSS_ERROR(maj_stat))
400 {
401 sasl_gss_seterror(text->utils, maj_stat, min_stat);
402 if (output_token->value)
403 gss_release_buffer(&min_stat, output_token);
404 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
405 UNLOCK_MUTEX(&global_mutex);
406 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
407 return SASL_FAIL;
408 }
409
410 if (output_token->value && output) {
411 int len;
412
413 ret = _plug_buf_alloc(text->utils, &(text->encode_buf),
414 &(text->encode_buf_len), output_token->length + 4);
415
416 if (ret != SASL_OK) {
417 gss_release_buffer(&min_stat, output_token);
418 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
419 UNLOCK_MUTEX(&global_mutex);
420 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
421 return ret;
422 }
423
424 len = htonl(output_token->length);
425 memcpy(text->encode_buf, &len, 4);
426 memcpy(text->encode_buf + 4, output_token->value, output_token->length);
427 }
428
429 if (outputlen) {
430 *outputlen = output_token->length + 4;
431 }
432
433 *output = text->encode_buf;
434
435 if (output_token->value)
436 gss_release_buffer(&min_stat, output_token);
437
438 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
439 UNLOCK_MUTEX(&global_mutex);
440 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
441
442 return SASL_OK;
443 }
444
445 static int gssapi_privacy_encode(void *context, const struct iovec *invec,
446 unsigned numiov, const char **output,
447 unsigned *outputlen)
448 {
449 return sasl_gss_encode(context,invec,numiov,output,outputlen,1);
450 }
451
452 static int gssapi_integrity_encode(void *context, const struct iovec *invec,
453 unsigned numiov, const char **output,
454 unsigned *outputlen)
455 {
456 return sasl_gss_encode(context,invec,numiov,output,outputlen,0);
457 }
458
459 #define myMIN(a,b) (((a) < (b)) ? (a) : (b))
460
461 static int gssapi_decode_once(void *context,
462 const char **input, unsigned *inputlen,
463 char **output, unsigned *outputlen)
464 {
465 context_t *text = (context_t *) context;
466 OM_uint32 maj_stat, min_stat;
467 gss_buffer_t input_token, output_token;
468 gss_buffer_desc real_input_token, real_output_token;
469 int result;
470 unsigned diff;
471
472 if (text->state != SASL_GSSAPI_STATE_AUTHENTICATED) {
473 #ifdef _INTEGRATED_SOLARIS_
474 SETERROR(text->utils, gettext("GSSAPI Failure"));
475 #else
476 SETERROR(text->utils, "GSSAPI Failure");
477 #endif /* _INTEGRATED_SOLARIS_ */
478 return SASL_NOTDONE;
479 }
480
481 /* first we need to extract a packet */
482 if (text->needsize > 0) {
483 /* how long is it? */
484 int tocopy = myMIN(text->needsize, *inputlen);
485
486 memcpy(text->sizebuf + 4 - text->needsize, *input, tocopy);
487 text->needsize -= tocopy;
488 *input += tocopy;
489 *inputlen -= tocopy;
490
491 if (text->needsize == 0) {
492 /* got the entire size */
493 memcpy(&text->size, text->sizebuf, 4);
494 text->size = ntohl(text->size);
495 text->cursize = 0;
496
497 #ifdef _SUN_SDK_
498 if (text->size > 0xFFFFFF) {
499 text->utils->log(text->utils->conn, SASL_LOG_ERR,
500 "Illegal size in sasl_gss_decode_once");
501 #else
502 if (text->size > 0xFFFFFF || text->size <= 0) {
503 SETERROR(text->utils, "Illegal size in sasl_gss_decode_once");
504 #endif /* _SUN_SDK_ */
505 return SASL_FAIL;
506 }
507
508 if (text->bufsize < text->size + 5) {
509 result = _plug_buf_alloc(text->utils, &text->buffer,
510 &(text->bufsize), text->size+5);
511 if(result != SASL_OK) return result;
512 }
513 }
514 if (*inputlen == 0) {
515 /* need more data ! */
516 *outputlen = 0;
517 *output = NULL;
518
519 return SASL_OK;
520 }
521 }
522
523 diff = text->size - text->cursize;
524
525 if (*inputlen < diff) {
526 /* ok, let's queue it up; not enough data */
527 memcpy(text->buffer + text->cursize, *input, *inputlen);
528 text->cursize += *inputlen;
529 *inputlen = 0;
530 *outputlen = 0;
531 *output = NULL;
532 return SASL_OK;
533 } else {
534 memcpy(text->buffer + text->cursize, *input, diff);
535 *input += diff;
536 *inputlen -= diff;
537 }
538
539 input_token = &real_input_token;
540 real_input_token.value = text->buffer;
541 real_input_token.length = text->size;
542
543 output_token = &real_output_token;
544 output_token->value = NULL;
545 output_token->length = 0;
546
547 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
548 if (LOCK_MUTEX(&global_mutex) < 0)
549 return (SASL_FAIL);
550 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
551
552 maj_stat = gss_unwrap (&min_stat,
553 text->gss_ctx,
554 input_token,
555 output_token,
556 NULL,
557 NULL);
558
559 if (GSS_ERROR(maj_stat))
560 {
561 sasl_gss_seterror(text->utils, maj_stat, min_stat);
562 if (output_token->value)
563 gss_release_buffer(&min_stat, output_token);
564 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
565 UNLOCK_MUTEX(&global_mutex);
566 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
567 return SASL_FAIL;
568 }
569
570 if (outputlen)
571 *outputlen = output_token->length;
572
573 if (output_token->value) {
574 if (output) {
575 result = _plug_buf_alloc(text->utils, &text->decode_once_buf,
576 &text->decode_once_buf_len,
577 *outputlen);
578 if(result != SASL_OK) {
579 gss_release_buffer(&min_stat, output_token);
580 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
581 UNLOCK_MUTEX(&global_mutex);
582 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
583 return result;
584 }
585 *output = text->decode_once_buf;
586 memcpy(*output, output_token->value, *outputlen);
587 }
588 gss_release_buffer(&min_stat, output_token);
589 }
590 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
591 UNLOCK_MUTEX(&global_mutex);
592 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
593
594 /* reset for the next packet */
595 #ifndef _SUN_SDK_
596 text->size = -1;
597 #endif /* !_SUN_SDK_ */
598 text->needsize = 4;
599
600 return SASL_OK;
601 }
602
603 static int gssapi_decode(void *context,
604 const char *input, unsigned inputlen,
605 const char **output, unsigned *outputlen)
606 {
607 context_t *text = (context_t *) context;
608 int ret;
609
610 ret = _plug_decode(text->utils, context, input, inputlen,
611 &text->decode_buf, &text->decode_buf_len, outputlen,
612 gssapi_decode_once);
613
614 *output = text->decode_buf;
615
616 return ret;
617 }
618
619 static context_t *gss_new_context(const sasl_utils_t *utils)
620 {
621 context_t *ret;
622
623 ret = utils->malloc(sizeof(context_t));
624 if(!ret) return NULL;
625
626 memset(ret,0,sizeof(context_t));
627 ret->utils = utils;
628 #ifdef _SUN_SDK_
629 ret->gss_ctx = GSS_C_NO_CONTEXT;
630 ret->client_name = GSS_C_NO_NAME;
631 ret->server_name = GSS_C_NO_NAME;
632 ret->server_creds = GSS_C_NO_CREDENTIAL;
633 ret->client_creds = GSS_C_NO_CREDENTIAL;
634 if (get_oid(utils, &ret->mech_oid) != SASL_OK) {
635 utils->free(ret);
636 return (NULL);
637 }
638 #endif /* _SUN_SDK_ */
639
640 ret->needsize = 4;
641
642 return ret;
643 }
644
645 static void sasl_gss_free_context_contents(context_t *text)
646 {
647 OM_uint32 maj_stat, min_stat;
648
649 if (!text) return;
650
651 if (text->gss_ctx != GSS_C_NO_CONTEXT) {
652 maj_stat = gss_delete_sec_context (&min_stat,&text->gss_ctx,GSS_C_NO_BUFFER);
653 text->gss_ctx = GSS_C_NO_CONTEXT;
654 }
655
656 if (text->client_name != GSS_C_NO_NAME) {
657 maj_stat = gss_release_name(&min_stat,&text->client_name);
658 text->client_name = GSS_C_NO_NAME;
659 }
660
661 if (text->server_name != GSS_C_NO_NAME) {
662 maj_stat = gss_release_name(&min_stat,&text->server_name);
663 text->server_name = GSS_C_NO_NAME;
664 }
665
666 if ( text->server_creds != GSS_C_NO_CREDENTIAL) {
667 maj_stat = gss_release_cred(&min_stat, &text->server_creds);
668 text->server_creds = GSS_C_NO_CREDENTIAL;
669 }
670
671 #ifdef _SUN_SDK_
672 if ( text->client_creds != GSS_C_NO_CREDENTIAL) {
673 maj_stat = gss_release_cred(&min_stat, &text->client_creds);
674 text->client_creds = GSS_C_NO_CREDENTIAL;
675 }
676
677 /*
678 * Note that the oid returned by rpc_gss_mech_to_oid should not
679 * be released
680 */
681 #endif /* _SUN_SDK_ */
682
683 if (text->out_buf) {
684 text->utils->free(text->out_buf);
685 text->out_buf = NULL;
686 }
687
688 if (text->encode_buf) {
689 text->utils->free(text->encode_buf);
690 text->encode_buf = NULL;
691 }
692
693 if (text->decode_buf) {
694 text->utils->free(text->decode_buf);
695 text->decode_buf = NULL;
696 }
697
698 if (text->decode_once_buf) {
699 text->utils->free(text->decode_once_buf);
700 text->decode_once_buf = NULL;
701 }
702
703 if (text->enc_in_buf) {
704 if(text->enc_in_buf->data) text->utils->free(text->enc_in_buf->data);
705 text->utils->free(text->enc_in_buf);
706 text->enc_in_buf = NULL;
707 }
708
709 if (text->buffer) {
710 text->utils->free(text->buffer);
711 text->buffer = NULL;
712 }
713
714 if (text->authid) { /* works for both client and server */
715 text->utils->free(text->authid);
716 text->authid = NULL;
717 }
718 }
719
720 #ifdef _SUN_SDK_
721
722 #ifdef HAVE_RPC_GSS_MECH_TO_OID
723 #include <rpc/rpcsec_gss.h>
724 #endif /* HAVE_RPC_GSS_MECH_TO_OID */
725
726 static int
727 get_oid(const sasl_utils_t *utils, gss_OID *oid)
728 {
729 #ifdef HAVE_RPC_GSS_MECH_TO_OID
730 static gss_OID_desc kerb_v5 =
731 {9, (void *)"\x2a\x86\x48\x86\xf7\x12\x01\x02\x02"};
732 /* 1.2.840.113554.1.2.2 */
733 *oid = &kerb_v5;
734 #endif /* HAVE_RPC_GSS_MECH_TO_OID */
735 return (SASL_OK);
736 }
737
738 static int
739 add_mech_to_set(context_t *text, gss_OID_set *desired_mechs)
740 {
741 OM_uint32 maj_stat, min_stat;
742
743 maj_stat = gss_create_empty_oid_set(&min_stat, desired_mechs);
744
745 if (GSS_ERROR(maj_stat)) {
746 sasl_gss_seterror(text->utils, maj_stat, min_stat);
747 sasl_gss_free_context_contents(text);
748 return SASL_FAIL;
749 }
750
751 maj_stat = gss_add_oid_set_member(&min_stat, text->mech_oid, desired_mechs);
752 if (GSS_ERROR(maj_stat)) {
753 sasl_gss_seterror(text->utils, maj_stat, min_stat);
754 sasl_gss_free_context_contents(text);
755 (void) gss_release_oid_set(&min_stat, desired_mechs);
756 return SASL_FAIL;
757 }
758 return SASL_OK;
759 }
760 #endif /* _SUN_SDK_ */
761
762 static void gssapi_common_mech_dispose(void *conn_context,
763 const sasl_utils_t *utils)
764 {
765 #ifdef _SUN_SDK_
766 if (conn_context == NULL)
767 return;
768 #ifdef _INTEGRATED_SOLARIS_
769 convert_prompt(utils, &((context_t *)conn_context)->h, NULL);
770 #endif /* _INTEGRATED_SOLARIS_ */
771 #endif /* _SUN_SDK_ */
772 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
773 (void) LOCK_MUTEX(&global_mutex);
774 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
775 sasl_gss_free_context_contents((context_t *)(conn_context));
776 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
777 UNLOCK_MUTEX(&global_mutex);
778 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
779 utils->free(conn_context);
780 }
781
782 /***************************** Server Section *****************************/
783
784 static int
785 gssapi_server_mech_new(void *glob_context __attribute__((unused)),
786 sasl_server_params_t *params,
787 const char *challenge __attribute__((unused)),
788 unsigned challen __attribute__((unused)),
789 void **conn_context)
790 {
791 context_t *text;
792
793 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
794 if (LOCK_MUTEX(&global_mutex) < 0)
795 return (SASL_FAIL);
796 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
797 text = gss_new_context(params->utils);
798 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
799 UNLOCK_MUTEX(&global_mutex);
800 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
801 if (text == NULL) {
802 #ifndef _SUN_SDK_
803 MEMERROR(params->utils);
804 #endif /* !_SUN_SDK_ */
805 return SASL_NOMEM;
806 }
807
808 text->gss_ctx = GSS_C_NO_CONTEXT;
809 text->client_name = GSS_C_NO_NAME;
810 text->server_name = GSS_C_NO_NAME;
811 text->server_creds = GSS_C_NO_CREDENTIAL;
812 text->state = SASL_GSSAPI_STATE_AUTHNEG;
813
814 *conn_context = text;
815
816 return SASL_OK;
817 }
818
819 static int
820 gssapi_server_mech_step(void *conn_context,
821 sasl_server_params_t *params,
822 const char *clientin,
823 unsigned clientinlen,
824 const char **serverout,
825 unsigned *serveroutlen,
826 sasl_out_params_t *oparams)
827 {
828 context_t *text = (context_t *)conn_context;
829 gss_buffer_t input_token, output_token;
830 gss_buffer_desc real_input_token, real_output_token;
831 OM_uint32 maj_stat, min_stat;
832 #ifdef _SUN_SDK_
833 OM_uint32 max_input_size;
834 gss_OID_set desired_mechs = GSS_C_NULL_OID_SET;
835 #endif /* _SUN_SDK_ */
836 gss_buffer_desc name_token;
837 int ret;
838
839 input_token = &real_input_token;
840 output_token = &real_output_token;
841 output_token->value = NULL; output_token->length = 0;
842 input_token->value = NULL; input_token->length = 0;
843
844 if(!serverout) {
845 PARAMERROR(text->utils);
846 return SASL_BADPARAM;
847 }
848
849 *serverout = NULL;
850 *serveroutlen = 0;
851
852 switch (text->state) {
853
854 case SASL_GSSAPI_STATE_AUTHNEG:
855 if (text->server_name == GSS_C_NO_NAME) { /* only once */
856 name_token.length = strlen(params->service) + 1 + strlen(params->serverFQDN);
857 name_token.value = (char *)params->utils->malloc((name_token.length + 1) * sizeof(char));
858 if (name_token.value == NULL) {
859 MEMERROR(text->utils);
860 sasl_gss_free_context_contents(text);
861 return SASL_NOMEM;
862 }
863 #ifdef _SUN_SDK_
864 snprintf(name_token.value, name_token.length + 1,
865 "%s@%s", params->service, params->serverFQDN);
866 #else
867 sprintf(name_token.value,"%s@%s", params->service, params->serverFQDN);
868 #endif /* _SUN_SDK_ */
869
870 maj_stat = gss_import_name (&min_stat,
871 &name_token,
872 GSS_C_NT_HOSTBASED_SERVICE,
873 &text->server_name);
874
875 params->utils->free(name_token.value);
876 name_token.value = NULL;
877
878 if (GSS_ERROR(maj_stat)) {
879 sasl_gss_seterror(text->utils, maj_stat, min_stat);
880 sasl_gss_free_context_contents(text);
881 return SASL_FAIL;
882 }
883
884 if ( text->server_creds != GSS_C_NO_CREDENTIAL) {
885 maj_stat = gss_release_cred(&min_stat, &text->server_creds);
886 text->server_creds = GSS_C_NO_CREDENTIAL;
887 }
888
889 #ifdef _SUN_SDK_
890 if (text->mech_oid != GSS_C_NULL_OID) {
891 ret = add_mech_to_set(text, &desired_mechs);
892 if (ret != SASL_OK)
893 return (ret);
894 }
895 #endif /* _SUN_SDK_ */
896
897 maj_stat = gss_acquire_cred(&min_stat,
898 text->server_name,
899 GSS_C_INDEFINITE,
900 #ifdef _SUN_SDK_
901 desired_mechs,
902 #else
903 GSS_C_NO_OID_SET,
904 #endif /* _SUN_SDK_ */
905 GSS_C_ACCEPT,
906 &text->server_creds,
907 NULL,
908 NULL);
909
910 #ifdef _SUN_SDK_
911 if (desired_mechs != GSS_C_NULL_OID_SET) {
912 OM_uint32 min_stat2;
913 (void) gss_release_oid_set(&min_stat2, &desired_mechs);
914 }
915 #endif /* _SUN_SDK_ */
916
917 if (GSS_ERROR(maj_stat)) {
918 sasl_gss_seterror(text->utils, maj_stat, min_stat);
919 sasl_gss_free_context_contents(text);
920 return SASL_FAIL;
921 }
922 }
923
924 if (clientinlen) {
925 real_input_token.value = (void *)clientin;
926 real_input_token.length = clientinlen;
927 }
928
929 maj_stat =
930 gss_accept_sec_context(&min_stat,
931 &(text->gss_ctx),
932 text->server_creds,
933 input_token,
934 GSS_C_NO_CHANNEL_BINDINGS,
935 &text->client_name,
936 NULL,
937 output_token,
938 NULL,
939 NULL,
940 NULL);
941
942 if (GSS_ERROR(maj_stat)) {
943 #ifdef _SUN_SDK_
944 /* log the local error info, set a more generic error */
945 sasl_gss_log(text->utils, maj_stat, min_stat);
946 text->utils->seterror(text->utils->conn, SASL_NOLOG,
947 gettext("GSSAPI Failure: accept security context error"));
948 if (output_token->value) {
949 gss_release_buffer(&min_stat, output_token);
950 }
951 #else
952 if (output_token->value) {
953 gss_release_buffer(&min_stat, output_token);
954 }
955 text->utils->seterror(text->utils->conn, SASL_NOLOG, "GSSAPI Failure: gss_accept_sec_context");
956 text->utils->log(NULL, SASL_LOG_DEBUG, "GSSAPI Failure: gss_accept_sec_context");
957 #endif /* _SUN_SDK_ */
958 sasl_gss_free_context_contents(text);
959 return SASL_BADAUTH;
960 }
961
962 if (serveroutlen)
963 *serveroutlen = output_token->length;
964 if (output_token->value) {
965 if (serverout) {
966 ret = _plug_buf_alloc(text->utils, &(text->out_buf),
967 &(text->out_buf_len), *serveroutlen);
968 if(ret != SASL_OK) {
969 gss_release_buffer(&min_stat, output_token);
970 return ret;
971 }
972 memcpy(text->out_buf, output_token->value, *serveroutlen);
973 *serverout = text->out_buf;
974 }
975
976 gss_release_buffer(&min_stat, output_token);
977 } else {
978 /* No output token, send an empty string */
979 *serverout = GSSAPI_BLANK_STRING;
980 #ifndef _SUN_SDK_
981 serveroutlen = 0;
982 #endif /* !_SUN_SDK_ */
983 }
984
985
986 if (maj_stat == GSS_S_COMPLETE) {
987 /* Switch to ssf negotiation */
988 text->state = SASL_GSSAPI_STATE_SSFCAP;
989 }
990
991 return SASL_CONTINUE;
992
993 case SASL_GSSAPI_STATE_SSFCAP: {
994 unsigned char sasldata[4];
995 gss_buffer_desc name_token;
996 #ifndef _SUN_SDK_
997 gss_buffer_desc name_without_realm;
998 gss_name_t without = NULL;
999 int equal;
1000 #endif /* !_SUN_SDK_ */
1001
1002 name_token.value = NULL;
1003 #ifndef _SUN_SDK_
1004 name_without_realm.value = NULL;
1005 #endif /* !_SUN_SDK_ */
1006
1007 /* We ignore whatever the client sent us at this stage */
1008
1009 maj_stat = gss_display_name (&min_stat,
1010 text->client_name,
1011 &name_token,
1012 NULL);
1013
1014 if (GSS_ERROR(maj_stat)) {
1015 #ifndef _SUN_SDK_
1016 if (name_without_realm.value)
1017 params->utils->free(name_without_realm.value);
1018 #endif /* !_SUN_SDK_ */
1019
1020 if (name_token.value)
1021 gss_release_buffer(&min_stat, &name_token);
1022 #ifndef _SUN_SDK_
1023 if (without)
1024 gss_release_name(&min_stat, &without);
1025 #endif /* !_SUN_SDK_ */
1026 #ifdef _INTEGRATED_SOLARIS_
1027 SETERROR(text->utils, gettext("GSSAPI Failure"));
1028 #else
1029 SETERROR(text->utils, "GSSAPI Failure");
1030 #endif /* _INTEGRATED_SOLARIS_ */
1031 sasl_gss_free_context_contents(text);
1032 return SASL_BADAUTH;
1033 }
1034
1035 #ifndef _SUN_SDK_
1036 /* If the id contains a realm get the identifier for the user
1037 without the realm and see if it's the same id (i.e.
1038 tmartin == tmartin@ANDREW.CMU.EDU. If this is the case we just want
1039 to return the id (i.e. just "tmartin" */
1040 if (strchr((char *) name_token.value, (int) '@') != NULL) {
1041 /* NOTE: libc malloc, as it is freed below by a gssapi internal
1042 * function! */
1043 name_without_realm.value = malloc(strlen(name_token.value)+1);
1044 if (name_without_realm.value == NULL) {
1045 MEMERROR(text->utils);
1046 return SASL_NOMEM;
1047 }
1048
1049 strcpy(name_without_realm.value, name_token.value);
1050
1051 /* cut off string at '@' */
1052 (strchr(name_without_realm.value,'@'))[0] = '\0';
1053
1054 name_without_realm.length = strlen( (char *) name_without_realm.value );
1055
1056 maj_stat = gss_import_name (&min_stat,
1057 &name_without_realm,
1058 /* Solaris 8/9 gss_import_name doesn't accept GSS_C_NULL_OID here,
1059 so use GSS_C_NT_USER_NAME instead if available. */
1060 #ifdef HAVE_GSS_C_NT_USER_NAME
1061 GSS_C_NT_USER_NAME,
1062 #else
1063 GSS_C_NULL_OID,
1064 #endif
1065 &without);
1066
1067 if (GSS_ERROR(maj_stat)) {
1068 params->utils->free(name_without_realm.value);
1069 if (name_token.value)
1070 gss_release_buffer(&min_stat, &name_token);
1071 if (without)
1072 gss_release_name(&min_stat, &without);
1073 SETERROR(text->utils, "GSSAPI Failure");
1074 sasl_gss_free_context_contents(text);
1075 return SASL_BADAUTH;
1076 }
1077
1078 maj_stat = gss_compare_name(&min_stat,
1079 text->client_name,
1080 without,
1081 &equal);
1082
1083 if (GSS_ERROR(maj_stat)) {
1084 params->utils->free(name_without_realm.value);
1085 if (name_token.value)
1086 gss_release_buffer(&min_stat, &name_token);
1087 if (without)
1088 gss_release_name(&min_stat, &without);
1089 SETERROR(text->utils, "GSSAPI Failure");
1090 sasl_gss_free_context_contents(text);
1091 return SASL_BADAUTH;
1092 }
1093
1094 gss_release_name(&min_stat,&without);
1095 } else {
1096 equal = 0;
1097 }
1098
1099 if (equal) {
1100 text->authid = strdup(name_without_realm.value);
1101
1102 if (text->authid == NULL) {
1103 MEMERROR(params->utils);
1104 return SASL_NOMEM;
1105 }
1106 } else {
1107 text->authid = strdup(name_token.value);
1108
1109 if (text->authid == NULL) {
1110 MEMERROR(params->utils);
1111 return SASL_NOMEM;
1112 }
1113 }
1114 #else
1115 {
1116 ret = _plug_strdup(params->utils, name_token.value,
1117 &text->authid, NULL);
1118 }
1119 #endif /* _SUN_SDK_ */
1120
1121 if (name_token.value)
1122 gss_release_buffer(&min_stat, &name_token);
1123
1124 #ifdef _SUN_SDK_
1125 if (ret != SASL_OK)
1126 return (ret);
1127 #else
1128 if (name_without_realm.value)
1129 params->utils->free(name_without_realm.value);
1130 #endif /* _SUN_SDK_ */
1131
1132
1133 /* we have to decide what sort of encryption/integrity/etc.,
1134 we support */
1135 if (params->props.max_ssf < params->external_ssf) {
1136 text->limitssf = 0;
1137 } else {
1138 text->limitssf = params->props.max_ssf - params->external_ssf;
1139 }
1140 if (params->props.min_ssf < params->external_ssf) {
1141 text->requiressf = 0;
1142 } else {
1143 text->requiressf = params->props.min_ssf - params->external_ssf;
1144 }
1145
1146 /* build up our security properties token */
1147 if (params->props.maxbufsize > 0xFFFFFF) {
1148 /* make sure maxbufsize isn't too large */
1149 /* maxbufsize = 0xFFFFFF */
1150 sasldata[1] = sasldata[2] = sasldata[3] = 0xFF;
1151 } else {
1152 sasldata[1] = (params->props.maxbufsize >> 16) & 0xFF;
1153 sasldata[2] = (params->props.maxbufsize >> 8) & 0xFF;
1154 sasldata[3] = (params->props.maxbufsize >> 0) & 0xFF;
1155 }
1156 sasldata[0] = 0;
1157 if(text->requiressf != 0 && !params->props.maxbufsize) {
1158 #ifdef _SUN_SDK_
1159 params->utils->log(params->utils->conn, SASL_LOG_ERR,
1160 "GSSAPI needs a security layer but one is forbidden");
1161 #else
1162 params->utils->seterror(params->utils->conn, 0,
1163 "GSSAPI needs a security layer but one is forbidden");
1164 #endif /* _SUN_SDK_ */
1165 return SASL_TOOWEAK;
1166 }
1167
1168 if (text->requiressf == 0) {
1169 sasldata[0] |= 1; /* authentication */
1170 }
1171 if (text->requiressf <= 1 && text->limitssf >= 1
1172 && params->props.maxbufsize) {
1173 sasldata[0] |= 2;
1174 }
1175 if (text->requiressf <= 56 && text->limitssf >= 56
1176 && params->props.maxbufsize) {
1177 sasldata[0] |= 4;
1178 }
1179
1180 real_input_token.value = (void *)sasldata;
1181 real_input_token.length = 4;
1182
1183 maj_stat = gss_wrap(&min_stat,
1184 text->gss_ctx,
1185 0, /* Just integrity checking here */
1186 GSS_C_QOP_DEFAULT,
1187 input_token,
1188 NULL,
1189 output_token);
1190
1191 if (GSS_ERROR(maj_stat)) {
1192 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1193 if (output_token->value)
1194 gss_release_buffer(&min_stat, output_token);
1195 sasl_gss_free_context_contents(text);
1196 return SASL_FAIL;
1197 }
1198
1199
1200 if (serveroutlen)
1201 *serveroutlen = output_token->length;
1202 if (output_token->value) {
1203 if (serverout) {
1204 ret = _plug_buf_alloc(text->utils, &(text->out_buf),
1205 &(text->out_buf_len), *serveroutlen);
1206 if(ret != SASL_OK) {
1207 gss_release_buffer(&min_stat, output_token);
1208 return ret;
1209 }
1210 memcpy(text->out_buf, output_token->value, *serveroutlen);
1211 *serverout = text->out_buf;
1212 }
1213
1214 gss_release_buffer(&min_stat, output_token);
1215 }
1216
1217 /* Wait for ssf request and authid */
1218 text->state = SASL_GSSAPI_STATE_SSFREQ;
1219
1220 return SASL_CONTINUE;
1221 }
1222
1223 case SASL_GSSAPI_STATE_SSFREQ: {
1224 int layerchoice;
1225
1226 real_input_token.value = (void *)clientin;
1227 real_input_token.length = clientinlen;
1228
1229 maj_stat = gss_unwrap(&min_stat,
1230 text->gss_ctx,
1231 input_token,
1232 output_token,
1233 NULL,
1234 NULL);
1235
1236 if (GSS_ERROR(maj_stat)) {
1237 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1238 sasl_gss_free_context_contents(text);
1239 return SASL_FAIL;
1240 }
1241
1242 layerchoice = (int)(((char *)(output_token->value))[0]);
1243 if (layerchoice == 1 && text->requiressf == 0) { /* no encryption */
1244 oparams->encode = NULL;
1245 oparams->decode = NULL;
1246 oparams->mech_ssf = 0;
1247 } else if (layerchoice == 2 && text->requiressf <= 1 &&
1248 text->limitssf >= 1) { /* integrity */
1249 oparams->encode=&gssapi_integrity_encode;
1250 oparams->decode=&gssapi_decode;
1251 oparams->mech_ssf=1;
1252 } else if (layerchoice == 4 && text->requiressf <= 56 &&
1253 text->limitssf >= 56) { /* privacy */
1254 oparams->encode = &gssapi_privacy_encode;
1255 oparams->decode = &gssapi_decode;
1256 oparams->mech_ssf = 56;
1257 } else {
1258 /* not a supported encryption layer */
1259 #ifdef _SUN_SDK_
1260 text->utils->log(text->utils->conn, SASL_LOG_ERR,
1261 "protocol violation: client requested invalid layer");
1262 #else
1263 SETERROR(text->utils,
1264 "protocol violation: client requested invalid layer");
1265 #endif /* _SUN_SDK_ */
1266 /* Mark that we attempted negotiation */
1267 oparams->mech_ssf = 2;
1268 if (output_token->value)
1269 gss_release_buffer(&min_stat, output_token);
1270 sasl_gss_free_context_contents(text);
1271 return SASL_FAIL;
1272 }
1273
1274 if (output_token->length > 4) {
1275 int ret;
1276
1277 ret = params->canon_user(params->utils->conn,
1278 ((char *) output_token->value) + 4,
1279 (output_token->length - 4) * sizeof(char),
1280 SASL_CU_AUTHZID, oparams);
1281
1282 if (ret != SASL_OK) {
1283 sasl_gss_free_context_contents(text);
1284 return ret;
1285 }
1286
1287 ret = params->canon_user(params->utils->conn,
1288 text->authid,
1289 0, /* strlen(text->authid) */
1290 SASL_CU_AUTHID, oparams);
1291 if (ret != SASL_OK) {
1292 sasl_gss_free_context_contents(text);
1293 return ret;
1294 }
1295 } else if(output_token->length == 4) {
1296 /* null authzid */
1297 int ret;
1298
1299 ret = params->canon_user(params->utils->conn,
1300 text->authid,
1301 0, /* strlen(text->authid) */
1302 SASL_CU_AUTHZID | SASL_CU_AUTHID,
1303 oparams);
1304
1305 if (ret != SASL_OK) {
1306 sasl_gss_free_context_contents(text);
1307 return ret;
1308 }
1309 } else {
1310 #ifdef _SUN_SDK_
1311 text->utils->log(text->utils->conn, SASL_LOG_ERR,
1312 "token too short");
1313 #else
1314 SETERROR(text->utils,
1315 "token too short");
1316 #endif /* _SUN_SDK_ */
1317 gss_release_buffer(&min_stat, output_token);
1318 sasl_gss_free_context_contents(text);
1319 return SASL_FAIL;
1320 }
1321
1322 /* No matter what, set the rest of the oparams */
1323 oparams->maxoutbuf =
1324 (((unsigned char *) output_token->value)[1] << 16) |
1325 (((unsigned char *) output_token->value)[2] << 8) |
1326 (((unsigned char *) output_token->value)[3] << 0);
1327
1328 #ifdef _SUN_SDK_
1329 if (oparams->mech_ssf) {
1330 oparams->maxoutbuf -= 4; /* Allow for 4 byte tag */
1331 maj_stat = gss_wrap_size_limit(&min_stat,
1332 text->gss_ctx,
1333 oparams->mech_ssf > 1,
1334 GSS_C_QOP_DEFAULT,
1335 oparams->maxoutbuf,
1336 &max_input_size);
1337 if (GSS_ERROR(maj_stat)) {
1338 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1339 (void) gss_release_buffer(&min_stat, output_token);
1340 sasl_gss_free_context_contents(text);
1341 return (SASL_FAIL);
1342 }
1343
1344 /*
1345 * gss_wrap_size_limit will return very big sizes for
1346 * small input values
1347 */
1348 if (max_input_size < oparams->maxoutbuf)
1349 oparams->maxoutbuf = max_input_size;
1350 else {
1351 oparams->maxoutbuf = 0;
1352 }
1353 }
1354 #else
1355 if (oparams->mech_ssf) {
1356 /* xxx this is probably too big */
1357 oparams->maxoutbuf -= 50;
1358 }
1359 #endif /* _SUN_SDK_ */
1360
1361 gss_release_buffer(&min_stat, output_token);
1362
1363 text->state = SASL_GSSAPI_STATE_AUTHENTICATED;
1364
1365 oparams->doneflag = 1;
1366
1367 return SASL_OK;
1368 }
1369
1370 default:
1371 #ifdef _SUN_SDK_
1372 params->utils->log(text->utils->conn, SASL_LOG_ERR,
1373 "Invalid GSSAPI server step %d", text->state);
1374 #else
1375 params->utils->log(NULL, SASL_LOG_ERR,
1376 "Invalid GSSAPI server step %d\n", text->state);
1377 #endif /* _SUN_SDK_ */
1378 return SASL_FAIL;
1379 }
1380
1381 #ifndef _SUN_SDK_
1382 return SASL_FAIL; /* should never get here */
1383 #endif /* !_SUN_SDK_ */
1384 }
1385
1386 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
1387 static int
1388 _gssapi_server_mech_step(void *conn_context,
1389 sasl_server_params_t *params,
1390 const char *clientin,
1391 unsigned clientinlen,
1392 const char **serverout,
1393 unsigned *serveroutlen,
1394 sasl_out_params_t *oparams)
1395 {
1396 int ret;
1397
1398 if (LOCK_MUTEX(&global_mutex) < 0)
1399 return (SASL_FAIL);
1400
1401 ret = gssapi_server_mech_step(conn_context, params, clientin, clientinlen,
1402 serverout, serveroutlen, oparams);
1403
1404 UNLOCK_MUTEX(&global_mutex);
1405 return (ret);
1406 }
1407 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
1408
1409 static sasl_server_plug_t gssapi_server_plugins[] =
1410 {
1411 {
1412 "GSSAPI", /* mech_name */
1413 56, /* max_ssf */
1414 SASL_SEC_NOPLAINTEXT
1415 | SASL_SEC_NOACTIVE
1416 | SASL_SEC_NOANONYMOUS
1417 | SASL_SEC_MUTUAL_AUTH, /* security_flags */
1418 SASL_FEAT_WANT_CLIENT_FIRST
1419 | SASL_FEAT_ALLOWS_PROXY, /* features */
1420 NULL, /* glob_context */
1421 &gssapi_server_mech_new, /* mech_new */
1422 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
1423 &_gssapi_server_mech_step, /* mech_step */
1424 #else
1425 &gssapi_server_mech_step, /* mech_step */
1426 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
1427 &gssapi_common_mech_dispose, /* mech_dispose */
1428 NULL, /* mech_free */
1429 NULL, /* setpass */
1430 NULL, /* user_query */
1431 NULL, /* idle */
1432 NULL, /* mech_avail */
1433 NULL /* spare */
1434 }
1435 };
1436
1437 int gssapiv2_server_plug_init(
1438 #ifndef HAVE_GSSKRB5_REGISTER_ACCEPTOR_IDENTITY
1439 const sasl_utils_t *utils __attribute__((unused)),
1440 #else
1441 const sasl_utils_t *utils,
1442 #endif
1443 int maxversion,
1444 int *out_version,
1445 sasl_server_plug_t **pluglist,
1446 int *plugcount)
1447 {
1448 #ifdef HAVE_GSSKRB5_REGISTER_ACCEPTOR_IDENTITY
1449 const char *keytab = NULL;
1450 char keytab_path[1024];
1451 unsigned int rl;
1452 #endif
1453
1454 if (maxversion < SASL_SERVER_PLUG_VERSION) {
1455 return SASL_BADVERS;
1456 }
1457
1458 #ifndef _SUN_SDK_
1459 #ifdef HAVE_GSSKRB5_REGISTER_ACCEPTOR_IDENTITY
1460 /* unfortunately, we don't check for readability of keytab if it's
1461 the standard one, since we don't know where it is */
1462
1463 /* FIXME: This code is broken */
1464
1465 utils->getopt(utils->getopt_context, "GSSAPI", "keytab", &keytab, &rl);
1466 if (keytab != NULL) {
1467 if (access(keytab, R_OK) != 0) {
1468 utils->log(NULL, SASL_LOG_ERR,
1469 "Could not find keytab file: %s: %m",
1470 keytab, errno);
1471 return SASL_FAIL;
1472 }
1473
1474 if(strlen(keytab) > 1024) {
1475 utils->log(NULL, SASL_LOG_ERR,
1476 "path to keytab is > 1024 characters");
1477 return SASL_BUFOVER;
1478 }
1479
1480 strncpy(keytab_path, keytab, 1024);
1481
1482 gsskrb5_register_acceptor_identity(keytab_path);
1483 }
1484 #endif
1485 #endif /* !_SUN_SDK_ */
1486
1487 #ifdef _INTEGRATED_SOLARIS_
1488 /*
1489 * Let libsasl know that we are a "Sun" plugin so that privacy
1490 * and integrity will be allowed.
1491 */
1492 REG_PLUG("GSSAPI", gssapi_server_plugins);
1493 #endif /* _INTEGRATED_SOLARIS_ */
1494
1495 *out_version = SASL_SERVER_PLUG_VERSION;
1496 *pluglist = gssapi_server_plugins;
1497 *plugcount = 1;
1498
1499 return SASL_OK;
1500 }
1501
1502 /***************************** Client Section *****************************/
1503
1504 static int gssapi_client_mech_new(void *glob_context __attribute__((unused)),
1505 sasl_client_params_t *params,
1506 void **conn_context)
1507 {
1508 context_t *text;
1509 #ifdef _SUN_SDK_
1510 const char *use_authid = NULL;
1511 #endif /* _SUN_SDK_ */
1512
1513 /* holds state are in */
1514 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
1515 if (LOCK_MUTEX(&global_mutex) < 0)
1516 return (SASL_FAIL);
1517 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
1518 text = gss_new_context(params->utils);
1519 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
1520 UNLOCK_MUTEX(&global_mutex);
1521 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
1522 if (text == NULL) {
1523 #ifndef _SUN_SDK_
1524 MEMERROR(params->utils);
1525 #endif /* !_SUN_SDK_ */
1526 return SASL_NOMEM;
1527 }
1528
1529 text->state = SASL_GSSAPI_STATE_AUTHNEG;
1530 text->gss_ctx = GSS_C_NO_CONTEXT;
1531 text->client_name = GSS_C_NO_NAME;
1532 text->server_creds = GSS_C_NO_CREDENTIAL;
1533
1534 #ifdef _SUN_SDK_
1535 params->utils->getopt(params->utils->getopt_context,
1536 "GSSAPI", "use_authid", &use_authid, NULL);
1537 text->use_authid = (use_authid != NULL) &&
1538 (*use_authid == 'y' || *use_authid == 'Y' || *use_authid == '1');
1539 #endif /* _SUN_SDK_ */
1540
1541 *conn_context = text;
1542
1543 return SASL_OK;
1544 }
1545
1546 static int gssapi_client_mech_step(void *conn_context,
1547 sasl_client_params_t *params,
1548 const char *serverin,
1549 unsigned serverinlen,
1550 sasl_interact_t **prompt_need,
1551 const char **clientout,
1552 unsigned *clientoutlen,
1553 sasl_out_params_t *oparams)
1554 {
1555 context_t *text = (context_t *)conn_context;
1556 gss_buffer_t input_token, output_token;
1557 gss_buffer_desc real_input_token, real_output_token;
1558 OM_uint32 maj_stat, min_stat;
1559 #ifdef _SUN_SDK_
1560 OM_uint32 max_input_size;
1561 #endif /* _SUN_SDK_ */
1562 gss_buffer_desc name_token;
1563 int ret;
1564 OM_uint32 req_flags, out_req_flags;
1565 input_token = &real_input_token;
1566 output_token = &real_output_token;
1567 output_token->value = NULL;
1568 input_token->value = NULL;
1569 input_token->length = 0;
1570
1571 *clientout = NULL;
1572 *clientoutlen = 0;
1573
1574 switch (text->state) {
1575
1576 case SASL_GSSAPI_STATE_AUTHNEG:
1577 /* try to get the userid */
1578 #ifdef _SUN_SDK_
1579 if (text->user == NULL ||
1580 (text->use_authid && text->client_authid == NULL)) {
1581 int auth_result = SASL_OK;
1582 int user_result = SASL_OK;
1583
1584 if (text->use_authid && text->client_authid == NULL) {
1585 auth_result = _plug_get_authid(params->utils,
1586 &text->client_authid,
1587 prompt_need);
1588
1589 if ((auth_result != SASL_OK) &&
1590 (auth_result != SASL_INTERACT)) {
1591 sasl_gss_free_context_contents(text);
1592 return auth_result;
1593 }
1594 }
1595 if (text->user == NULL) {
1596 user_result = _plug_get_userid(params->utils, &text->user,
1597 prompt_need);
1598
1599 if ((user_result != SASL_OK) &&
1600 (user_result != SASL_INTERACT)) {
1601 sasl_gss_free_context_contents(text);
1602 return user_result;
1603 }
1604 }
1605 #else
1606 if (text->user == NULL) {
1607 int user_result = SASL_OK;
1608
1609 user_result = _plug_get_userid(params->utils, &text->user,
1610 prompt_need);
1611
1612 if ((user_result != SASL_OK) && (user_result != SASL_INTERACT)) {
1613 sasl_gss_free_context_contents(text);
1614 return user_result;
1615 }
1616 #endif /* _SUN_SDK_ */
1617
1618 /* free prompts we got */
1619 if (prompt_need && *prompt_need) {
1620 params->utils->free(*prompt_need);
1621 *prompt_need = NULL;
1622 }
1623
1624 /* if there are prompts not filled in */
1625 #ifdef _SUN_SDK_
1626 if ((user_result == SASL_INTERACT) ||
1627 (auth_result == SASL_INTERACT)) {
1628 /* make the prompt list */
1629 #ifdef _INTEGRATED_SOLARIS_
1630 int result = _plug_make_prompts(params->utils, &text->h,
1631 prompt_need,
1632 user_result == SASL_INTERACT ?
1633 convert_prompt(params->utils, &text->h,
1634 gettext("Please enter your authorization name"))
1635 : NULL, NULL,
1636 auth_result == SASL_INTERACT ?
1637 convert_prompt(params->utils, &text->h,
1638 gettext("Please enter your authentication name"))
1639 : NULL, NULL,
1640 NULL, NULL,
1641 NULL, NULL, NULL,
1642 NULL, NULL, NULL);
1643 #else
1644 int result = _plug_make_prompts(params->utils, prompt_need,
1645 user_result == SASL_INTERACT ?
1646 "Please enter your authorization name"
1647 : NULL, NULL,
1648 auth_result == SASL_INTERACT ?
1649 "Please enter your authentication name"
1650 : NULL, NULL,
1651 NULL, NULL,
1652 NULL, NULL, NULL,
1653 NULL, NULL, NULL);
1654 #endif /* _INTEGRATED_SOLARIS_ */
1655
1656 if (result != SASL_OK) return result;
1657
1658 return SASL_INTERACT;
1659 }
1660 #else
1661 if (user_result == SASL_INTERACT) {
1662 /* make the prompt list */
1663 int result =
1664 _plug_make_prompts(params->utils, prompt_need,
1665 user_result == SASL_INTERACT ?
1666 "Please enter your authorization name" : NULL, NULL,
1667 NULL, NULL,
1668 NULL, NULL,
1669 NULL, NULL, NULL,
1670 NULL, NULL, NULL);
1671 if (result != SASL_OK) return result;
1672
1673 return SASL_INTERACT;
1674 }
1675 #endif /* _SUN_SDK_ */
1676 }
1677
1678 if (text->server_name == GSS_C_NO_NAME) { /* only once */
1679 name_token.length = strlen(params->service) + 1 + strlen(params->serverFQDN);
1680 name_token.value = (char *)params->utils->malloc((name_token.length + 1) * sizeof(char));
1681 if (name_token.value == NULL) {
1682 sasl_gss_free_context_contents(text);
1683 return SASL_NOMEM;
1684 }
1685 if (params->serverFQDN == NULL
1686 || strlen(params->serverFQDN) == 0) {
1687 #ifdef _SUN_SDK_
1688 text->utils->log(text->utils->conn, SASL_LOG_ERR,
1689 "GSSAPI Failure: no serverFQDN");
1690 #else
1691 SETERROR(text->utils, "GSSAPI Failure: no serverFQDN");
1692 #endif /* _SUN_SDK_ */
1693 return SASL_FAIL;
1694 }
1695
1696 #ifdef _SUN_SDK_
1697 snprintf(name_token.value, name_token.length + 1,
1698 "%s@%s", params->service, params->serverFQDN);
1699 #else
1700 sprintf(name_token.value,"%s@%s", params->service, params->serverFQDN);
1701 #endif /* _SUN_SDK_ */
1702
1703 maj_stat = gss_import_name (&min_stat,
1704 &name_token,
1705 GSS_C_NT_HOSTBASED_SERVICE,
1706 &text->server_name);
1707
1708 params->utils->free(name_token.value);
1709 name_token.value = NULL;
1710
1711 if (GSS_ERROR(maj_stat)) {
1712 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1713 sasl_gss_free_context_contents(text);
1714 return SASL_FAIL;
1715 }
1716 }
1717
1718 if (serverinlen == 0)
1719 input_token = GSS_C_NO_BUFFER;
1720
1721 if (serverinlen) {
1722 real_input_token.value = (void *)serverin;
1723 real_input_token.length = serverinlen;
1724 }
1725 else if (text->gss_ctx != GSS_C_NO_CONTEXT ) {
1726 /* This can't happen under GSSAPI: we have a non-null context
1727 * and no input from the server. However, thanks to Imap,
1728 * which discards our first output, this happens all the time.
1729 * Throw away the context and try again. */
1730 maj_stat = gss_delete_sec_context (&min_stat,&text->gss_ctx,GSS_C_NO_BUFFER);
1731 text->gss_ctx = GSS_C_NO_CONTEXT;
1732 }
1733
1734 /* Setup req_flags properly */
1735 req_flags = GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG;
1736 if(params->props.max_ssf > params->external_ssf) {
1737 /* We are requesting a security layer */
1738 req_flags |= GSS_C_INTEG_FLAG;
1739 if(params->props.max_ssf - params->external_ssf > 56) {
1740 /* We want to try for privacy */
1741 req_flags |= GSS_C_CONF_FLAG;
1742 }
1743 }
1744
1745 #ifdef _SUN_SDK_
1746 if (text->use_authid && text->client_creds == GSS_C_NO_CREDENTIAL) {
1747 gss_OID_set desired_mechs = GSS_C_NULL_OID_SET;
1748 gss_buffer_desc name_token;
1749
1750 name_token.length = strlen(text->client_authid);
1751 name_token.value = (char *)text->client_authid;
1752
1753 maj_stat = gss_import_name (&min_stat,
1754 &name_token,
1755 #ifdef HAVE_GSS_C_NT_USER_NAME
1756 GSS_C_NT_USER_NAME,
1757 #else
1758 GSS_C_NULL_OID,
1759 #endif
1760 &text->client_name);
1761 if (GSS_ERROR(maj_stat)) {
1762 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1763 sasl_gss_free_context_contents(text);
1764 return SASL_FAIL;
1765 }
1766
1767 if (text->mech_oid != GSS_C_NULL_OID) {
1768 ret = add_mech_to_set(text, &desired_mechs);
1769 if (ret != SASL_OK)
1770 return (ret);
1771 }
1772
1773 maj_stat = gss_acquire_cred(&min_stat,
1774 text->client_name,
1775 GSS_C_INDEFINITE,
1776 desired_mechs,
1777 GSS_C_INITIATE,
1778 &text->client_creds,
1779 NULL,
1780 NULL);
1781
1782 if (desired_mechs != GSS_C_NULL_OID_SET) {
1783 OM_uint32 min_stat2;
1784 (void) gss_release_oid_set(&min_stat2, &desired_mechs);
1785 }
1786
1787 if (GSS_ERROR(maj_stat)) {
1788 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1789 sasl_gss_free_context_contents(text);
1790 return SASL_FAIL;
1791 }
1792 }
1793 #endif /* _SUN_SDK_ */
1794
1795 maj_stat = gss_init_sec_context(&min_stat,
1796 #ifdef _SUN_SDK_
1797 text->client_creds,
1798 #else
1799 GSS_C_NO_CREDENTIAL,
1800 #endif /* _SUN_SDK_ */
1801 &text->gss_ctx,
1802 text->server_name,
1803 #ifdef _SUN_SDK_
1804 text->mech_oid,
1805 #else
1806 GSS_C_NO_OID,
1807 #endif /* _SUN_SDK_ */
1808 req_flags,
1809 0,
1810 GSS_C_NO_CHANNEL_BINDINGS,
1811 input_token,
1812 NULL,
1813 output_token,
1814 &out_req_flags,
1815 NULL);
1816
1817 if (GSS_ERROR(maj_stat)) {
1818 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1819 if (output_token->value)
1820 gss_release_buffer(&min_stat, output_token);
1821 sasl_gss_free_context_contents(text);
1822 return SASL_FAIL;
1823 }
1824
1825 *clientoutlen = output_token->length;
1826
1827 if (output_token->value) {
1828 if (clientout) {
1829 ret = _plug_buf_alloc(text->utils, &(text->out_buf),
1830 &(text->out_buf_len), *clientoutlen);
1831 if(ret != SASL_OK) {
1832 gss_release_buffer(&min_stat, output_token);
1833 return ret;
1834 }
1835 memcpy(text->out_buf, output_token->value, *clientoutlen);
1836 *clientout = text->out_buf;
1837 }
1838
1839 gss_release_buffer(&min_stat, output_token);
1840 }
1841
1842 if (maj_stat == GSS_S_COMPLETE) {
1843 maj_stat = gss_inquire_context(&min_stat,
1844 text->gss_ctx,
1845 &text->client_name,
1846 NULL, /* targ_name */
1847 NULL, /* lifetime */
1848 NULL, /* mech */
1849 NULL, /* flags */
1850 NULL, /* local init */
1851 NULL); /* open */
1852
1853 if (GSS_ERROR(maj_stat)) {
1854 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1855 sasl_gss_free_context_contents(text);
1856 return SASL_FAIL;
1857 }
1858
1859 name_token.length = 0;
1860 maj_stat = gss_display_name(&min_stat,
1861 text->client_name,
1862 &name_token,
1863 NULL);
1864
1865 if (GSS_ERROR(maj_stat)) {
1866 if (name_token.value)
1867 gss_release_buffer(&min_stat, &name_token);
1868 #ifdef _INTEGRATED_SOLARIS_
1869 SETERROR(text->utils, gettext("GSSAPI Failure"));
1870 #else
1871 SETERROR(text->utils, "GSSAPI Failure");
1872 #endif /* _INTEGRATED_SOLARIS_ */
1873 sasl_gss_free_context_contents(text);
1874 return SASL_FAIL;
1875 }
1876
1877 if (text->user && text->user[0]) {
1878 ret = params->canon_user(params->utils->conn,
1879 text->user, 0,
1880 SASL_CU_AUTHZID, oparams);
1881 if (ret == SASL_OK)
1882 ret = params->canon_user(params->utils->conn,
1883 name_token.value, 0,
1884 SASL_CU_AUTHID, oparams);
1885 } else {
1886 ret = params->canon_user(params->utils->conn,
1887 name_token.value, 0,
1888 SASL_CU_AUTHID | SASL_CU_AUTHZID,
1889 oparams);
1890 }
1891 gss_release_buffer(&min_stat, &name_token);
1892
1893 if (ret != SASL_OK) return ret;
1894
1895 /* Switch to ssf negotiation */
1896 text->state = SASL_GSSAPI_STATE_SSFCAP;
1897 }
1898
1899 return SASL_CONTINUE;
1900
1901 case SASL_GSSAPI_STATE_SSFCAP: {
1902 sasl_security_properties_t *secprops = &(params->props);
1903 unsigned int alen, external = params->external_ssf;
1904 sasl_ssf_t need, allowed;
1905 char serverhas, mychoice;
1906
1907 real_input_token.value = (void *) serverin;
1908 real_input_token.length = serverinlen;
1909
1910 maj_stat = gss_unwrap(&min_stat,
1911 text->gss_ctx,
1912 input_token,
1913 output_token,
1914 NULL,
1915 NULL);
1916
1917 if (GSS_ERROR(maj_stat)) {
1918 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1919 sasl_gss_free_context_contents(text);
1920 if (output_token->value)
1921 gss_release_buffer(&min_stat, output_token);
1922 return SASL_FAIL;
1923 }
1924
1925 /* taken from kerberos.c */
1926 if (secprops->min_ssf > (56 + external)) {
1927 return SASL_TOOWEAK;
1928 } else if (secprops->min_ssf > secprops->max_ssf) {
1929 return SASL_BADPARAM;
1930 }
1931
1932 /* need bits of layer -- sasl_ssf_t is unsigned so be careful */
1933 if (secprops->max_ssf >= external) {
1934 allowed = secprops->max_ssf - external;
1935 } else {
1936 allowed = 0;
1937 }
1938 if (secprops->min_ssf >= external) {
1939 need = secprops->min_ssf - external;
1940 } else {
1941 /* good to go */
1942 need = 0;
1943 }
1944
1945 /* bit mask of server support */
1946 serverhas = ((char *)output_token->value)[0];
1947
1948 /* if client didn't set use strongest layer available */
1949 if (allowed >= 56 && need <= 56 && (serverhas & 4)) {
1950 /* encryption */
1951 oparams->encode = &gssapi_privacy_encode;
1952 oparams->decode = &gssapi_decode;
1953 oparams->mech_ssf = 56;
1954 mychoice = 4;
1955 } else if (allowed >= 1 && need <= 1 && (serverhas & 2)) {
1956 /* integrity */
1957 oparams->encode = &gssapi_integrity_encode;
1958 oparams->decode = &gssapi_decode;
1959 oparams->mech_ssf = 1;
1960 mychoice = 2;
1961 #ifdef _SUN_SDK_
1962 } else if (need == 0 && (serverhas & 1)) {
1963 #else
1964 } else if (need <= 0 && (serverhas & 1)) {
1965 #endif /* _SUN_SDK_ */
1966 /* no layer */
1967 oparams->encode = NULL;
1968 oparams->decode = NULL;
1969 oparams->mech_ssf = 0;
1970 mychoice = 1;
1971 } else {
1972 /* there's no appropriate layering for us! */
1973 sasl_gss_free_context_contents(text);
1974 return SASL_TOOWEAK;
1975 }
1976
1977 oparams->maxoutbuf =
1978 (((unsigned char *) output_token->value)[1] << 16) |
1979 (((unsigned char *) output_token->value)[2] << 8) |
1980 (((unsigned char *) output_token->value)[3] << 0);
1981
1982 #ifdef _SUN_SDK_
1983 if (oparams->mech_ssf > 0) {
1984 oparams->maxoutbuf -= 4; /* Space for 4 byte length header */
1985 maj_stat = gss_wrap_size_limit(&min_stat,
1986 text->gss_ctx,
1987 oparams->mech_ssf > 1,
1988 GSS_C_QOP_DEFAULT,
1989 oparams->maxoutbuf,
1990 &max_input_size);
1991 if (GSS_ERROR(maj_stat)) {
1992 sasl_gss_seterror(text->utils, maj_stat, min_stat);
1993 (void) gss_release_buffer(&min_stat, output_token);
1994 sasl_gss_free_context_contents(text);
1995 return (SASL_FAIL);
1996 }
1997
1998 /*
1999 * This is a workaround for a Solaris bug where
2000 * gss_wrap_size_limit may return very big sizes for
2001 * small input values
2002 */
2003 if (max_input_size < oparams->maxoutbuf)
2004 oparams->maxoutbuf = max_input_size;
2005 else {
2006 oparams->maxoutbuf = 0;
2007 }
2008 }
2009 #else
2010 if(oparams->mech_ssf) {
2011 /* xxx probably too large */
2012 oparams->maxoutbuf -= 50;
2013 }
2014 #endif /* _SUN_SDK_ */
2015
2016 gss_release_buffer(&min_stat, output_token);
2017
2018 /* oparams->user is always set, due to canon_user requirements.
2019 * Make sure the client actually requested it though, by checking
2020 * if our context was set.
2021 */
2022 if (text->user && text->user[0])
2023 alen = strlen(oparams->user);
2024 else
2025 alen = 0;
2026
2027 input_token->length = 4 + alen;
2028 input_token->value =
2029 (char *)params->utils->malloc((input_token->length + 1)*sizeof(char));
2030 if (input_token->value == NULL) {
2031 sasl_gss_free_context_contents(text);
2032 return SASL_NOMEM;
2033 }
2034
2035 if (alen)
2036 memcpy((char *)input_token->value+4,oparams->user,alen);
2037
2038 /* build up our security properties token */
2039 if (params->props.maxbufsize > 0xFFFFFF) {
2040 /* make sure maxbufsize isn't too large */
2041 /* maxbufsize = 0xFFFFFF */
2042 ((unsigned char *)input_token->value)[1] = 0xFF;
2043 ((unsigned char *)input_token->value)[2] = 0xFF;
2044 ((unsigned char *)input_token->value)[3] = 0xFF;
2045 } else {
2046 ((unsigned char *)input_token->value)[1] =
2047 (params->props.maxbufsize >> 16) & 0xFF;
2048 ((unsigned char *)input_token->value)[2] =
2049 (params->props.maxbufsize >> 8) & 0xFF;
2050 ((unsigned char *)input_token->value)[3] =
2051 (params->props.maxbufsize >> 0) & 0xFF;
2052 }
2053 ((unsigned char *)input_token->value)[0] = mychoice;
2054
2055 maj_stat = gss_wrap (&min_stat,
2056 text->gss_ctx,
2057 0, /* Just integrity checking here */
2058 GSS_C_QOP_DEFAULT,
2059 input_token,
2060 NULL,
2061 output_token);
2062
2063 params->utils->free(input_token->value);
2064 input_token->value = NULL;
2065
2066 if (GSS_ERROR(maj_stat)) {
2067 sasl_gss_seterror(text->utils, maj_stat, min_stat);
2068 if (output_token->value)
2069 gss_release_buffer(&min_stat, output_token);
2070 sasl_gss_free_context_contents(text);
2071 return SASL_FAIL;
2072 }
2073
2074 if (clientoutlen)
2075 *clientoutlen = output_token->length;
2076 if (output_token->value) {
2077 if (clientout) {
2078 ret = _plug_buf_alloc(text->utils, &(text->out_buf),
2079 &(text->out_buf_len), *clientoutlen);
2080 if (ret != SASL_OK) {
2081 gss_release_buffer(&min_stat, output_token);
2082 return ret;
2083 }
2084 memcpy(text->out_buf, output_token->value, *clientoutlen);
2085 *clientout = text->out_buf;
2086 }
2087
2088 gss_release_buffer(&min_stat, output_token);
2089 }
2090
2091 text->state = SASL_GSSAPI_STATE_AUTHENTICATED;
2092
2093 oparams->doneflag = 1;
2094
2095 return SASL_OK;
2096 }
2097
2098 default:
2099 #ifdef _SUN_SDK_
2100 params->utils->log(params->utils->conn, SASL_LOG_ERR,
2101 "Invalid GSSAPI client step %d", text->state);
2102 #else
2103 params->utils->log(NULL, SASL_LOG_ERR,
2104 "Invalid GSSAPI client step %d\n", text->state);
2105 #endif /* _SUN_SDK_ */
2106 return SASL_FAIL;
2107 }
2108
2109 #ifndef _SUN_SDK_
2110 return SASL_FAIL; /* should never get here */
2111 #endif /* !_SUN_SDK_ */
2112 }
2113
2114 #ifdef _SUN_SDK_
2115 static const unsigned long gssapi_required_prompts[] = {
2116 #else
2117 static const long gssapi_required_prompts[] = {
2118 #endif /* _SUN_SDK_ */
2119 SASL_CB_LIST_END
2120 };
2121
2122 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
2123 static int _gssapi_client_mech_step(void *conn_context,
2124 sasl_client_params_t *params,
2125 const char *serverin,
2126 unsigned serverinlen,
2127 sasl_interact_t **prompt_need,
2128 const char **clientout,
2129 unsigned *clientoutlen,
2130 sasl_out_params_t *oparams)
2131 {
2132 int ret;
2133
2134 if (LOCK_MUTEX(&global_mutex) < 0)
2135 return (SASL_FAIL);
2136
2137 ret = gssapi_client_mech_step(conn_context, params, serverin, serverinlen,
2138 prompt_need, clientout, clientoutlen, oparams);
2139
2140 UNLOCK_MUTEX(&global_mutex);
2141 return (ret);
2142 }
2143 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
2144
2145 static sasl_client_plug_t gssapi_client_plugins[] =
2146 {
2147 {
2148 "GSSAPI", /* mech_name */
2149 56, /* max_ssf */
2150 SASL_SEC_NOPLAINTEXT
2151 | SASL_SEC_NOACTIVE
2152 | SASL_SEC_NOANONYMOUS
2153 | SASL_SEC_MUTUAL_AUTH, /* security_flags */
2154 SASL_FEAT_WANT_CLIENT_FIRST
2155 | SASL_FEAT_ALLOWS_PROXY, /* features */
2156 gssapi_required_prompts, /* required_prompts */
2157 NULL, /* glob_context */
2158 &gssapi_client_mech_new, /* mech_new */
2159 #if defined _SUN_SDK_ && defined GSSAPI_PROTECT
2160 &_gssapi_client_mech_step, /* mech_step */
2161 #else
2162 &gssapi_client_mech_step, /* mech_step */
2163 #endif /* _SUN_SDK_ && GSSAPI_PROTECT */
2164 &gssapi_common_mech_dispose, /* mech_dispose */
2165 NULL, /* mech_free */
2166 NULL, /* idle */
2167 NULL, /* spare */
2168 NULL /* spare */
2169 }
2170 };
2171
2172 int gssapiv2_client_plug_init(const sasl_utils_t *utils __attribute__((unused)),
2173 int maxversion,
2174 int *out_version,
2175 sasl_client_plug_t **pluglist,
2176 int *plugcount)
2177 {
2178 if (maxversion < SASL_CLIENT_PLUG_VERSION) {
2179 SETERROR(utils, "Version mismatch in GSSAPI");
2180 return SASL_BADVERS;
2181 }
2182
2183 #ifdef _INTEGRATED_SOLARIS_
2184 /*
2185 * Let libsasl know that we are a "Sun" plugin so that privacy
2186 * and integrity will be allowed.
2187 */
2188 REG_PLUG("GSSAPI", gssapi_client_plugins);
2189 #endif /* _INTEGRATED_SOLARIS_ */
2190
2191 *out_version = SASL_CLIENT_PLUG_VERSION;
2192 *pluglist = gssapi_client_plugins;
2193 *plugcount = 1;
2194
2195 return SASL_OK;
2196 }
unleashed repo fork