113e3f4d6SMark Murray /*-
213e3f4d6SMark Murray * Copyright (c) 1992, 1993
313e3f4d6SMark Murray * The Regents of the University of California. All rights reserved.
413e3f4d6SMark Murray *
513e3f4d6SMark Murray * Redistribution and use in source and binary forms, with or without
613e3f4d6SMark Murray * modification, are permitted provided that the following conditions
713e3f4d6SMark Murray * are met:
813e3f4d6SMark Murray * 1. Redistributions of source code must retain the above copyright
913e3f4d6SMark Murray * notice, this list of conditions and the following disclaimer.
1013e3f4d6SMark Murray * 2. Redistributions in binary form must reproduce the above copyright
1113e3f4d6SMark Murray * notice, this list of conditions and the following disclaimer in the
1213e3f4d6SMark Murray * documentation and/or other materials provided with the distribution.
1313e3f4d6SMark Murray * 3. All advertising materials mentioning features or use of this software
1413e3f4d6SMark Murray * must display the following acknowledgement:
1513e3f4d6SMark Murray * This product includes software developed by the University of
1613e3f4d6SMark Murray * California, Berkeley and its contributors.
1713e3f4d6SMark Murray * 4. Neither the name of the University nor the names of its contributors
1813e3f4d6SMark Murray * may be used to endorse or promote products derived from this software
1913e3f4d6SMark Murray * without specific prior written permission.
2013e3f4d6SMark Murray *
2113e3f4d6SMark Murray * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
2213e3f4d6SMark Murray * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2313e3f4d6SMark Murray * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2413e3f4d6SMark Murray * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
2513e3f4d6SMark Murray * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2613e3f4d6SMark Murray * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2713e3f4d6SMark Murray * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2813e3f4d6SMark Murray * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2913e3f4d6SMark Murray * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
3013e3f4d6SMark Murray * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3113e3f4d6SMark Murray * SUCH DAMAGE.
3213e3f4d6SMark Murray */
3313e3f4d6SMark Murray
3413e3f4d6SMark Murray #include <config.h>
3513e3f4d6SMark Murray
36c19800e8SDoug Rabson RCSID("$Id$");
3713e3f4d6SMark Murray
3813e3f4d6SMark Murray #ifdef SPX
3913e3f4d6SMark Murray /*
4013e3f4d6SMark Murray * COPYRIGHT (C) 1990 DIGITAL EQUIPMENT CORPORATION
4113e3f4d6SMark Murray * ALL RIGHTS RESERVED
4213e3f4d6SMark Murray *
4313e3f4d6SMark Murray * "Digital Equipment Corporation authorizes the reproduction,
4413e3f4d6SMark Murray * distribution and modification of this software subject to the following
4513e3f4d6SMark Murray * restrictions:
4613e3f4d6SMark Murray *
4713e3f4d6SMark Murray * 1. Any partial or whole copy of this software, or any modification
4813e3f4d6SMark Murray * thereof, must include this copyright notice in its entirety.
4913e3f4d6SMark Murray *
5013e3f4d6SMark Murray * 2. This software is supplied "as is" with no warranty of any kind,
5113e3f4d6SMark Murray * expressed or implied, for any purpose, including any warranty of fitness
5213e3f4d6SMark Murray * or merchantibility. DIGITAL assumes no responsibility for the use or
5313e3f4d6SMark Murray * reliability of this software, nor promises to provide any form of
5413e3f4d6SMark Murray * support for it on any basis.
5513e3f4d6SMark Murray *
5613e3f4d6SMark Murray * 3. Distribution of this software is authorized only if no profit or
5713e3f4d6SMark Murray * remuneration of any kind is received in exchange for such distribution.
5813e3f4d6SMark Murray *
5913e3f4d6SMark Murray * 4. This software produces public key authentication certificates
6013e3f4d6SMark Murray * bearing an expiration date established by DIGITAL and RSA Data
6113e3f4d6SMark Murray * Security, Inc. It may cease to generate certificates after the expiration
6213e3f4d6SMark Murray * date. Any modification of this software that changes or defeats
6313e3f4d6SMark Murray * the expiration date or its effect is unauthorized.
6413e3f4d6SMark Murray *
6513e3f4d6SMark Murray * 5. Software that will renew or extend the expiration date of
6613e3f4d6SMark Murray * authentication certificates produced by this software may be obtained
6713e3f4d6SMark Murray * from RSA Data Security, Inc., 10 Twin Dolphin Drive, Redwood City, CA
6813e3f4d6SMark Murray * 94065, (415)595-8782, or from DIGITAL"
6913e3f4d6SMark Murray *
7013e3f4d6SMark Murray */
7113e3f4d6SMark Murray
7213e3f4d6SMark Murray #ifdef HAVE_SYS_TYPES_H
7313e3f4d6SMark Murray #include <sys/types.h>
7413e3f4d6SMark Murray #endif
7513e3f4d6SMark Murray #ifdef HAVE_ARPA_TELNET_H
7613e3f4d6SMark Murray #include <arpa/telnet.h>
7713e3f4d6SMark Murray #endif
7813e3f4d6SMark Murray #include <stdio.h>
7913e3f4d6SMark Murray #include "gssapi_defs.h"
8013e3f4d6SMark Murray #include <stdlib.h>
8113e3f4d6SMark Murray #include <string.h>
8213e3f4d6SMark Murray
8313e3f4d6SMark Murray #include <pwd.h>
8413e3f4d6SMark Murray #ifdef SOCKS
8513e3f4d6SMark Murray #include <socks.h>
8613e3f4d6SMark Murray #endif
8713e3f4d6SMark Murray
8813e3f4d6SMark Murray #include "encrypt.h"
8913e3f4d6SMark Murray #include "auth.h"
9013e3f4d6SMark Murray #include "misc.h"
9113e3f4d6SMark Murray
9213e3f4d6SMark Murray extern auth_debug_mode;
9313e3f4d6SMark Murray
9413e3f4d6SMark Murray static unsigned char str_data[1024] = { IAC, SB, TELOPT_AUTHENTICATION, 0,
9513e3f4d6SMark Murray AUTHTYPE_SPX, };
9613e3f4d6SMark Murray static unsigned char str_name[1024] = { IAC, SB, TELOPT_AUTHENTICATION,
9713e3f4d6SMark Murray TELQUAL_NAME, };
9813e3f4d6SMark Murray
9913e3f4d6SMark Murray #define SPX_AUTH 0 /* Authentication data follows */
10013e3f4d6SMark Murray #define SPX_REJECT 1 /* Rejected (reason might follow) */
10113e3f4d6SMark Murray #define SPX_ACCEPT 2 /* Accepted */
10213e3f4d6SMark Murray
10313e3f4d6SMark Murray static des_key_schedule sched;
10413e3f4d6SMark Murray static des_cblock challenge = { 0 };
10513e3f4d6SMark Murray
10613e3f4d6SMark Murray
10713e3f4d6SMark Murray /*******************************************************************/
10813e3f4d6SMark Murray
10913e3f4d6SMark Murray gss_OID_set actual_mechs;
11013e3f4d6SMark Murray gss_OID actual_mech_type, output_name_type;
11113e3f4d6SMark Murray int major_status, status, msg_ctx = 0, new_status;
11213e3f4d6SMark Murray int req_flags = 0, ret_flags, lifetime_rec;
11313e3f4d6SMark Murray gss_cred_id_t gss_cred_handle;
11413e3f4d6SMark Murray gss_ctx_id_t actual_ctxhandle, context_handle;
11513e3f4d6SMark Murray gss_buffer_desc output_token, input_token, input_name_buffer;
11613e3f4d6SMark Murray gss_buffer_desc status_string;
11713e3f4d6SMark Murray gss_name_t desired_targname, src_name;
11813e3f4d6SMark Murray gss_channel_bindings input_chan_bindings;
11913e3f4d6SMark Murray char lhostname[GSS_C_MAX_PRINTABLE_NAME];
12013e3f4d6SMark Murray char targ_printable[GSS_C_MAX_PRINTABLE_NAME];
12113e3f4d6SMark Murray int to_addr=0, from_addr=0;
12213e3f4d6SMark Murray char *address;
12313e3f4d6SMark Murray gss_buffer_desc fullname_buffer;
12413e3f4d6SMark Murray gss_OID fullname_type;
12513e3f4d6SMark Murray gss_cred_id_t gss_delegated_cred_handle;
12613e3f4d6SMark Murray
12713e3f4d6SMark Murray /*******************************************************************/
12813e3f4d6SMark Murray
12913e3f4d6SMark Murray
13013e3f4d6SMark Murray
13113e3f4d6SMark Murray static int
Data(ap,type,d,c)13213e3f4d6SMark Murray Data(ap, type, d, c)
13313e3f4d6SMark Murray Authenticator *ap;
13413e3f4d6SMark Murray int type;
13513e3f4d6SMark Murray void *d;
13613e3f4d6SMark Murray int c;
13713e3f4d6SMark Murray {
13813e3f4d6SMark Murray unsigned char *p = str_data + 4;
13913e3f4d6SMark Murray unsigned char *cd = (unsigned char *)d;
14013e3f4d6SMark Murray
14113e3f4d6SMark Murray if (c == -1)
14213e3f4d6SMark Murray c = strlen((char *)cd);
14313e3f4d6SMark Murray
14413e3f4d6SMark Murray if (0) {
14513e3f4d6SMark Murray printf("%s:%d: [%d] (%d)",
14613e3f4d6SMark Murray str_data[3] == TELQUAL_IS ? ">>>IS" : ">>>REPLY",
14713e3f4d6SMark Murray str_data[3],
14813e3f4d6SMark Murray type, c);
14913e3f4d6SMark Murray printd(d, c);
15013e3f4d6SMark Murray printf("\r\n");
15113e3f4d6SMark Murray }
15213e3f4d6SMark Murray *p++ = ap->type;
15313e3f4d6SMark Murray *p++ = ap->way;
15413e3f4d6SMark Murray *p++ = type;
15513e3f4d6SMark Murray while (c-- > 0) {
15613e3f4d6SMark Murray if ((*p++ = *cd++) == IAC)
15713e3f4d6SMark Murray *p++ = IAC;
15813e3f4d6SMark Murray }
15913e3f4d6SMark Murray *p++ = IAC;
16013e3f4d6SMark Murray *p++ = SE;
16113e3f4d6SMark Murray if (str_data[3] == TELQUAL_IS)
16213e3f4d6SMark Murray printsub('>', &str_data[2], p - (&str_data[2]));
16313e3f4d6SMark Murray return(telnet_net_write(str_data, p - str_data));
16413e3f4d6SMark Murray }
16513e3f4d6SMark Murray
16613e3f4d6SMark Murray int
spx_init(ap,server)16713e3f4d6SMark Murray spx_init(ap, server)
16813e3f4d6SMark Murray Authenticator *ap;
16913e3f4d6SMark Murray int server;
17013e3f4d6SMark Murray {
17113e3f4d6SMark Murray gss_cred_id_t tmp_cred_handle;
17213e3f4d6SMark Murray
17313e3f4d6SMark Murray if (server) {
17413e3f4d6SMark Murray str_data[3] = TELQUAL_REPLY;
17513e3f4d6SMark Murray gethostname(lhostname, sizeof(lhostname));
17613e3f4d6SMark Murray snprintf (targ_printable, sizeof(targ_printable),
17713e3f4d6SMark Murray "SERVICE:rcmd@%s", lhostname);
17813e3f4d6SMark Murray input_name_buffer.length = strlen(targ_printable);
17913e3f4d6SMark Murray input_name_buffer.value = targ_printable;
18013e3f4d6SMark Murray major_status = gss_import_name(&status,
18113e3f4d6SMark Murray &input_name_buffer,
18213e3f4d6SMark Murray GSS_C_NULL_OID,
18313e3f4d6SMark Murray &desired_targname);
18413e3f4d6SMark Murray major_status = gss_acquire_cred(&status,
18513e3f4d6SMark Murray desired_targname,
18613e3f4d6SMark Murray 0,
18713e3f4d6SMark Murray GSS_C_NULL_OID_SET,
18813e3f4d6SMark Murray GSS_C_ACCEPT,
18913e3f4d6SMark Murray &tmp_cred_handle,
19013e3f4d6SMark Murray &actual_mechs,
19113e3f4d6SMark Murray &lifetime_rec);
19213e3f4d6SMark Murray if (major_status != GSS_S_COMPLETE) return(0);
19313e3f4d6SMark Murray } else {
19413e3f4d6SMark Murray str_data[3] = TELQUAL_IS;
19513e3f4d6SMark Murray }
19613e3f4d6SMark Murray return(1);
19713e3f4d6SMark Murray }
19813e3f4d6SMark Murray
19913e3f4d6SMark Murray int
spx_send(ap)20013e3f4d6SMark Murray spx_send(ap)
20113e3f4d6SMark Murray Authenticator *ap;
20213e3f4d6SMark Murray {
20313e3f4d6SMark Murray des_cblock enckey;
20413e3f4d6SMark Murray int r;
20513e3f4d6SMark Murray
20613e3f4d6SMark Murray gss_OID actual_mech_type, output_name_type;
20713e3f4d6SMark Murray int msg_ctx = 0, new_status, status;
20813e3f4d6SMark Murray int req_flags = 0, ret_flags, lifetime_rec, major_status;
20913e3f4d6SMark Murray gss_buffer_desc output_token, input_token, input_name_buffer;
21013e3f4d6SMark Murray gss_buffer_desc output_name_buffer, status_string;
21113e3f4d6SMark Murray gss_name_t desired_targname;
21213e3f4d6SMark Murray gss_channel_bindings input_chan_bindings;
21313e3f4d6SMark Murray char targ_printable[GSS_C_MAX_PRINTABLE_NAME];
21413e3f4d6SMark Murray int from_addr=0, to_addr=0, myhostlen, j;
21513e3f4d6SMark Murray int deleg_flag=1, mutual_flag=0, replay_flag=0, seq_flag=0;
21613e3f4d6SMark Murray char *address;
21713e3f4d6SMark Murray
21813e3f4d6SMark Murray printf("[ Trying SPX ... ]\r\n");
21913e3f4d6SMark Murray snprintf (targ_printable, sizeof(targ_printable),
22013e3f4d6SMark Murray "SERVICE:rcmd@%s", RemoteHostName);
22113e3f4d6SMark Murray
22213e3f4d6SMark Murray input_name_buffer.length = strlen(targ_printable);
22313e3f4d6SMark Murray input_name_buffer.value = targ_printable;
22413e3f4d6SMark Murray
22513e3f4d6SMark Murray if (!UserNameRequested) {
22613e3f4d6SMark Murray return(0);
22713e3f4d6SMark Murray }
22813e3f4d6SMark Murray
22913e3f4d6SMark Murray major_status = gss_import_name(&status,
23013e3f4d6SMark Murray &input_name_buffer,
23113e3f4d6SMark Murray GSS_C_NULL_OID,
23213e3f4d6SMark Murray &desired_targname);
23313e3f4d6SMark Murray
23413e3f4d6SMark Murray
23513e3f4d6SMark Murray major_status = gss_display_name(&status,
23613e3f4d6SMark Murray desired_targname,
23713e3f4d6SMark Murray &output_name_buffer,
23813e3f4d6SMark Murray &output_name_type);
23913e3f4d6SMark Murray
24013e3f4d6SMark Murray printf("target is '%.*s'\n", (int)output_name_buffer.length,
24113e3f4d6SMark Murray (char*)output_name_buffer.value);
24213e3f4d6SMark Murray fflush(stdout);
24313e3f4d6SMark Murray
24413e3f4d6SMark Murray major_status = gss_release_buffer(&status, &output_name_buffer);
24513e3f4d6SMark Murray
24613e3f4d6SMark Murray input_chan_bindings = (gss_channel_bindings)
24713e3f4d6SMark Murray malloc(sizeof(gss_channel_bindings_desc));
24813e3f4d6SMark Murray
24913e3f4d6SMark Murray input_chan_bindings->initiator_addrtype = GSS_C_AF_INET;
25013e3f4d6SMark Murray input_chan_bindings->initiator_address.length = 4;
25113e3f4d6SMark Murray address = (char *) malloc(4);
25213e3f4d6SMark Murray input_chan_bindings->initiator_address.value = (char *) address;
25313e3f4d6SMark Murray address[0] = ((from_addr & 0xff000000) >> 24);
25413e3f4d6SMark Murray address[1] = ((from_addr & 0xff0000) >> 16);
25513e3f4d6SMark Murray address[2] = ((from_addr & 0xff00) >> 8);
25613e3f4d6SMark Murray address[3] = (from_addr & 0xff);
25713e3f4d6SMark Murray input_chan_bindings->acceptor_addrtype = GSS_C_AF_INET;
25813e3f4d6SMark Murray input_chan_bindings->acceptor_address.length = 4;
25913e3f4d6SMark Murray address = (char *) malloc(4);
26013e3f4d6SMark Murray input_chan_bindings->acceptor_address.value = (char *) address;
26113e3f4d6SMark Murray address[0] = ((to_addr & 0xff000000) >> 24);
26213e3f4d6SMark Murray address[1] = ((to_addr & 0xff0000) >> 16);
26313e3f4d6SMark Murray address[2] = ((to_addr & 0xff00) >> 8);
26413e3f4d6SMark Murray address[3] = (to_addr & 0xff);
26513e3f4d6SMark Murray input_chan_bindings->application_data.length = 0;
26613e3f4d6SMark Murray
26713e3f4d6SMark Murray req_flags = 0;
26813e3f4d6SMark Murray if (deleg_flag) req_flags = req_flags | 1;
26913e3f4d6SMark Murray if (mutual_flag) req_flags = req_flags | 2;
27013e3f4d6SMark Murray if (replay_flag) req_flags = req_flags | 4;
27113e3f4d6SMark Murray if (seq_flag) req_flags = req_flags | 8;
27213e3f4d6SMark Murray
27313e3f4d6SMark Murray major_status = gss_init_sec_context(&status, /* minor status */
27413e3f4d6SMark Murray GSS_C_NO_CREDENTIAL, /* cred handle */
27513e3f4d6SMark Murray &actual_ctxhandle, /* ctx handle */
27613e3f4d6SMark Murray desired_targname, /* target name */
27713e3f4d6SMark Murray GSS_C_NULL_OID, /* mech type */
27813e3f4d6SMark Murray req_flags, /* req flags */
27913e3f4d6SMark Murray 0, /* time req */
28013e3f4d6SMark Murray input_chan_bindings, /* chan binding */
28113e3f4d6SMark Murray GSS_C_NO_BUFFER, /* input token */
28213e3f4d6SMark Murray &actual_mech_type, /* actual mech */
28313e3f4d6SMark Murray &output_token, /* output token */
28413e3f4d6SMark Murray &ret_flags, /* ret flags */
28513e3f4d6SMark Murray &lifetime_rec); /* time rec */
28613e3f4d6SMark Murray
28713e3f4d6SMark Murray if ((major_status != GSS_S_COMPLETE) &&
28813e3f4d6SMark Murray (major_status != GSS_S_CONTINUE_NEEDED)) {
28913e3f4d6SMark Murray gss_display_status(&new_status,
29013e3f4d6SMark Murray status,
29113e3f4d6SMark Murray GSS_C_MECH_CODE,
29213e3f4d6SMark Murray GSS_C_NULL_OID,
29313e3f4d6SMark Murray &msg_ctx,
29413e3f4d6SMark Murray &status_string);
29513e3f4d6SMark Murray printf("%.*s\n", (int)status_string.length,
29613e3f4d6SMark Murray (char*)status_string.value);
29713e3f4d6SMark Murray return(0);
29813e3f4d6SMark Murray }
29913e3f4d6SMark Murray
30013e3f4d6SMark Murray if (!auth_sendname(UserNameRequested, strlen(UserNameRequested))) {
30113e3f4d6SMark Murray return(0);
30213e3f4d6SMark Murray }
30313e3f4d6SMark Murray
30413e3f4d6SMark Murray if (!Data(ap, SPX_AUTH, output_token.value, output_token.length)) {
30513e3f4d6SMark Murray return(0);
30613e3f4d6SMark Murray }
30713e3f4d6SMark Murray
30813e3f4d6SMark Murray return(1);
30913e3f4d6SMark Murray }
31013e3f4d6SMark Murray
31113e3f4d6SMark Murray void
spx_is(ap,data,cnt)31213e3f4d6SMark Murray spx_is(ap, data, cnt)
31313e3f4d6SMark Murray Authenticator *ap;
31413e3f4d6SMark Murray unsigned char *data;
31513e3f4d6SMark Murray int cnt;
31613e3f4d6SMark Murray {
31713e3f4d6SMark Murray Session_Key skey;
31813e3f4d6SMark Murray des_cblock datablock;
31913e3f4d6SMark Murray int r;
32013e3f4d6SMark Murray
32113e3f4d6SMark Murray if (cnt-- < 1)
32213e3f4d6SMark Murray return;
32313e3f4d6SMark Murray switch (*data++) {
32413e3f4d6SMark Murray case SPX_AUTH:
32513e3f4d6SMark Murray input_token.length = cnt;
32613e3f4d6SMark Murray input_token.value = (char *) data;
32713e3f4d6SMark Murray
32813e3f4d6SMark Murray gethostname(lhostname, sizeof(lhostname));
32913e3f4d6SMark Murray
33013e3f4d6SMark Murray snprintf(targ_printable, sizeof(targ_printable),
33113e3f4d6SMark Murray "SERVICE:rcmd@%s", lhostname);
33213e3f4d6SMark Murray
33313e3f4d6SMark Murray input_name_buffer.length = strlen(targ_printable);
33413e3f4d6SMark Murray input_name_buffer.value = targ_printable;
33513e3f4d6SMark Murray
33613e3f4d6SMark Murray major_status = gss_import_name(&status,
33713e3f4d6SMark Murray &input_name_buffer,
33813e3f4d6SMark Murray GSS_C_NULL_OID,
33913e3f4d6SMark Murray &desired_targname);
34013e3f4d6SMark Murray
34113e3f4d6SMark Murray major_status = gss_acquire_cred(&status,
34213e3f4d6SMark Murray desired_targname,
34313e3f4d6SMark Murray 0,
34413e3f4d6SMark Murray GSS_C_NULL_OID_SET,
34513e3f4d6SMark Murray GSS_C_ACCEPT,
34613e3f4d6SMark Murray &gss_cred_handle,
34713e3f4d6SMark Murray &actual_mechs,
34813e3f4d6SMark Murray &lifetime_rec);
34913e3f4d6SMark Murray
35013e3f4d6SMark Murray major_status = gss_release_name(&status, desired_targname);
35113e3f4d6SMark Murray
35213e3f4d6SMark Murray input_chan_bindings = (gss_channel_bindings)
35313e3f4d6SMark Murray malloc(sizeof(gss_channel_bindings_desc));
35413e3f4d6SMark Murray
35513e3f4d6SMark Murray input_chan_bindings->initiator_addrtype = GSS_C_AF_INET;
35613e3f4d6SMark Murray input_chan_bindings->initiator_address.length = 4;
35713e3f4d6SMark Murray address = (char *) malloc(4);
35813e3f4d6SMark Murray input_chan_bindings->initiator_address.value = (char *) address;
35913e3f4d6SMark Murray address[0] = ((from_addr & 0xff000000) >> 24);
36013e3f4d6SMark Murray address[1] = ((from_addr & 0xff0000) >> 16);
36113e3f4d6SMark Murray address[2] = ((from_addr & 0xff00) >> 8);
36213e3f4d6SMark Murray address[3] = (from_addr & 0xff);
36313e3f4d6SMark Murray input_chan_bindings->acceptor_addrtype = GSS_C_AF_INET;
36413e3f4d6SMark Murray input_chan_bindings->acceptor_address.length = 4;
36513e3f4d6SMark Murray address = (char *) malloc(4);
36613e3f4d6SMark Murray input_chan_bindings->acceptor_address.value = (char *) address;
36713e3f4d6SMark Murray address[0] = ((to_addr & 0xff000000) >> 24);
36813e3f4d6SMark Murray address[1] = ((to_addr & 0xff0000) >> 16);
36913e3f4d6SMark Murray address[2] = ((to_addr & 0xff00) >> 8);
37013e3f4d6SMark Murray address[3] = (to_addr & 0xff);
37113e3f4d6SMark Murray input_chan_bindings->application_data.length = 0;
37213e3f4d6SMark Murray
37313e3f4d6SMark Murray major_status = gss_accept_sec_context(&status,
37413e3f4d6SMark Murray &context_handle,
37513e3f4d6SMark Murray gss_cred_handle,
37613e3f4d6SMark Murray &input_token,
37713e3f4d6SMark Murray input_chan_bindings,
37813e3f4d6SMark Murray &src_name,
37913e3f4d6SMark Murray &actual_mech_type,
38013e3f4d6SMark Murray &output_token,
38113e3f4d6SMark Murray &ret_flags,
38213e3f4d6SMark Murray &lifetime_rec,
38313e3f4d6SMark Murray &gss_delegated_cred_handle);
38413e3f4d6SMark Murray
38513e3f4d6SMark Murray
38613e3f4d6SMark Murray if (major_status != GSS_S_COMPLETE) {
38713e3f4d6SMark Murray
38813e3f4d6SMark Murray major_status = gss_display_name(&status,
38913e3f4d6SMark Murray src_name,
39013e3f4d6SMark Murray &fullname_buffer,
39113e3f4d6SMark Murray &fullname_type);
39213e3f4d6SMark Murray Data(ap, SPX_REJECT, "auth failed", -1);
39313e3f4d6SMark Murray auth_finished(ap, AUTH_REJECT);
39413e3f4d6SMark Murray return;
39513e3f4d6SMark Murray }
39613e3f4d6SMark Murray
39713e3f4d6SMark Murray major_status = gss_display_name(&status,
39813e3f4d6SMark Murray src_name,
39913e3f4d6SMark Murray &fullname_buffer,
40013e3f4d6SMark Murray &fullname_type);
40113e3f4d6SMark Murray
40213e3f4d6SMark Murray
40313e3f4d6SMark Murray Data(ap, SPX_ACCEPT, output_token.value, output_token.length);
40413e3f4d6SMark Murray auth_finished(ap, AUTH_USER);
40513e3f4d6SMark Murray break;
40613e3f4d6SMark Murray
40713e3f4d6SMark Murray default:
40813e3f4d6SMark Murray Data(ap, SPX_REJECT, 0, 0);
40913e3f4d6SMark Murray break;
41013e3f4d6SMark Murray }
41113e3f4d6SMark Murray }
41213e3f4d6SMark Murray
41313e3f4d6SMark Murray
41413e3f4d6SMark Murray void
spx_reply(ap,data,cnt)41513e3f4d6SMark Murray spx_reply(ap, data, cnt)
41613e3f4d6SMark Murray Authenticator *ap;
41713e3f4d6SMark Murray unsigned char *data;
41813e3f4d6SMark Murray int cnt;
41913e3f4d6SMark Murray {
42013e3f4d6SMark Murray Session_Key skey;
42113e3f4d6SMark Murray
42213e3f4d6SMark Murray if (cnt-- < 1)
42313e3f4d6SMark Murray return;
42413e3f4d6SMark Murray switch (*data++) {
42513e3f4d6SMark Murray case SPX_REJECT:
42613e3f4d6SMark Murray if (cnt > 0) {
42713e3f4d6SMark Murray printf("[ SPX refuses authentication because %.*s ]\r\n",
42813e3f4d6SMark Murray cnt, data);
42913e3f4d6SMark Murray } else
43013e3f4d6SMark Murray printf("[ SPX refuses authentication ]\r\n");
43113e3f4d6SMark Murray auth_send_retry();
43213e3f4d6SMark Murray return;
43313e3f4d6SMark Murray case SPX_ACCEPT:
43413e3f4d6SMark Murray printf("[ SPX accepts you ]\r\n");
43513e3f4d6SMark Murray if ((ap->way & AUTH_HOW_MASK) == AUTH_HOW_MUTUAL) {
43613e3f4d6SMark Murray /*
43713e3f4d6SMark Murray * Send over the encrypted challenge.
43813e3f4d6SMark Murray */
43913e3f4d6SMark Murray input_token.value = (char *) data;
44013e3f4d6SMark Murray input_token.length = cnt;
44113e3f4d6SMark Murray
44213e3f4d6SMark Murray major_status = gss_init_sec_context(&status, /* minor stat */
44313e3f4d6SMark Murray GSS_C_NO_CREDENTIAL, /* cred handle */
44413e3f4d6SMark Murray &actual_ctxhandle, /* ctx handle */
44513e3f4d6SMark Murray desired_targname, /* target name */
44613e3f4d6SMark Murray GSS_C_NULL_OID, /* mech type */
44713e3f4d6SMark Murray req_flags, /* req flags */
44813e3f4d6SMark Murray 0, /* time req */
44913e3f4d6SMark Murray input_chan_bindings, /* chan binding */
45013e3f4d6SMark Murray &input_token, /* input token */
45113e3f4d6SMark Murray &actual_mech_type, /* actual mech */
45213e3f4d6SMark Murray &output_token, /* output token */
45313e3f4d6SMark Murray &ret_flags, /* ret flags */
45413e3f4d6SMark Murray &lifetime_rec); /* time rec */
45513e3f4d6SMark Murray
45613e3f4d6SMark Murray if (major_status != GSS_S_COMPLETE) {
45713e3f4d6SMark Murray gss_display_status(&new_status,
45813e3f4d6SMark Murray status,
45913e3f4d6SMark Murray GSS_C_MECH_CODE,
46013e3f4d6SMark Murray GSS_C_NULL_OID,
46113e3f4d6SMark Murray &msg_ctx,
46213e3f4d6SMark Murray &status_string);
46313e3f4d6SMark Murray printf("[ SPX mutual response fails ... '%.*s' ]\r\n",
46413e3f4d6SMark Murray (int)status_string.length,
46513e3f4d6SMark Murray (char*)status_string.value);
46613e3f4d6SMark Murray auth_send_retry();
46713e3f4d6SMark Murray return;
46813e3f4d6SMark Murray }
46913e3f4d6SMark Murray }
47013e3f4d6SMark Murray auth_finished(ap, AUTH_USER);
47113e3f4d6SMark Murray return;
47213e3f4d6SMark Murray
47313e3f4d6SMark Murray default:
47413e3f4d6SMark Murray return;
47513e3f4d6SMark Murray }
47613e3f4d6SMark Murray }
47713e3f4d6SMark Murray
47813e3f4d6SMark Murray int
spx_status(ap,name,name_sz,level)47913e3f4d6SMark Murray spx_status(ap, name, name_sz, level)
48013e3f4d6SMark Murray Authenticator *ap;
48113e3f4d6SMark Murray char *name;
48213e3f4d6SMark Murray size_t name_sz;
48313e3f4d6SMark Murray int level;
48413e3f4d6SMark Murray {
48513e3f4d6SMark Murray
48613e3f4d6SMark Murray gss_buffer_desc fullname_buffer, acl_file_buffer;
48713e3f4d6SMark Murray gss_OID fullname_type;
48813e3f4d6SMark Murray char acl_file[160], fullname[160];
48913e3f4d6SMark Murray int major_status, status = 0;
49013e3f4d6SMark Murray struct passwd *pwd;
49113e3f4d6SMark Murray
49213e3f4d6SMark Murray /*
49313e3f4d6SMark Murray * hard code fullname to
49413e3f4d6SMark Murray * "SPX:/C=US/O=Digital/OU=LKG/OU=Sphinx/OU=Users/CN=Kannan Alagappan"
49513e3f4d6SMark Murray * and acl_file to "~kannan/.sphinx"
49613e3f4d6SMark Murray */
49713e3f4d6SMark Murray
49813e3f4d6SMark Murray pwd = k_getpwnam(UserNameRequested);
49913e3f4d6SMark Murray if (pwd == NULL) {
50013e3f4d6SMark Murray return(AUTH_USER); /* not authenticated */
50113e3f4d6SMark Murray }
50213e3f4d6SMark Murray
50313e3f4d6SMark Murray snprintf (acl_file, sizeof(acl_file),
50413e3f4d6SMark Murray "%s/.sphinx", pwd->pw_dir);
50513e3f4d6SMark Murray
50613e3f4d6SMark Murray acl_file_buffer.value = acl_file;
50713e3f4d6SMark Murray acl_file_buffer.length = strlen(acl_file);
50813e3f4d6SMark Murray
50913e3f4d6SMark Murray major_status = gss_display_name(&status,
51013e3f4d6SMark Murray src_name,
51113e3f4d6SMark Murray &fullname_buffer,
51213e3f4d6SMark Murray &fullname_type);
51313e3f4d6SMark Murray
51413e3f4d6SMark Murray if (level < AUTH_USER)
51513e3f4d6SMark Murray return(level);
51613e3f4d6SMark Murray
51713e3f4d6SMark Murray major_status = gss__check_acl(&status, &fullname_buffer,
51813e3f4d6SMark Murray &acl_file_buffer);
51913e3f4d6SMark Murray
52013e3f4d6SMark Murray if (major_status == GSS_S_COMPLETE) {
52113e3f4d6SMark Murray strlcpy(name, UserNameRequested, name_sz);
52213e3f4d6SMark Murray return(AUTH_VALID);
52313e3f4d6SMark Murray } else {
52413e3f4d6SMark Murray return(AUTH_USER);
52513e3f4d6SMark Murray }
52613e3f4d6SMark Murray
52713e3f4d6SMark Murray }
52813e3f4d6SMark Murray
52913e3f4d6SMark Murray #define BUMP(buf, len) while (*(buf)) {++(buf), --(len);}
53013e3f4d6SMark Murray #define ADDC(buf, len, c) if ((len) > 0) {*(buf)++ = (c); --(len);}
53113e3f4d6SMark Murray
53213e3f4d6SMark Murray void
spx_printsub(unsigned char * data,size_t cnt,unsigned char * buf,size_t buflen)53313e3f4d6SMark Murray spx_printsub(unsigned char *data, size_t cnt,
53413e3f4d6SMark Murray unsigned char *buf, size_t buflen)
535c19800e8SDoug Rabson {
53613e3f4d6SMark Murray size_t i;
53713e3f4d6SMark Murray
53813e3f4d6SMark Murray buf[buflen-1] = '\0'; /* make sure it's NULL terminated */
53913e3f4d6SMark Murray buflen -= 1;
54013e3f4d6SMark Murray
54113e3f4d6SMark Murray switch(data[3]) {
54213e3f4d6SMark Murray case SPX_REJECT: /* Rejected (reason might follow) */
54313e3f4d6SMark Murray strlcpy((char *)buf, " REJECT ", buflen);
54413e3f4d6SMark Murray goto common;
54513e3f4d6SMark Murray
54613e3f4d6SMark Murray case SPX_ACCEPT: /* Accepted (name might follow) */
54713e3f4d6SMark Murray strlcpy((char *)buf, " ACCEPT ", buflen);
54813e3f4d6SMark Murray common:
54913e3f4d6SMark Murray BUMP(buf, buflen);
55013e3f4d6SMark Murray if (cnt <= 4)
55113e3f4d6SMark Murray break;
55213e3f4d6SMark Murray ADDC(buf, buflen, '"');
55313e3f4d6SMark Murray for (i = 4; i < cnt; i++)
55413e3f4d6SMark Murray ADDC(buf, buflen, data[i]);
55513e3f4d6SMark Murray ADDC(buf, buflen, '"');
55613e3f4d6SMark Murray ADDC(buf, buflen, '\0');
55713e3f4d6SMark Murray break;
55813e3f4d6SMark Murray
55913e3f4d6SMark Murray case SPX_AUTH: /* Authentication data follows */
56013e3f4d6SMark Murray strlcpy((char *)buf, " AUTH", buflen);
56113e3f4d6SMark Murray goto common2;
56213e3f4d6SMark Murray
56313e3f4d6SMark Murray default:
56413e3f4d6SMark Murray snprintf(buf, buflen, " %d (unknown)", data[3]);
56513e3f4d6SMark Murray common2:
56613e3f4d6SMark Murray BUMP(buf, buflen);
56713e3f4d6SMark Murray for (i = 4; i < cnt; i++) {
56813e3f4d6SMark Murray snprintf(buf, buflen, " %d", data[i]);
56913e3f4d6SMark Murray BUMP(buf, buflen);
57013e3f4d6SMark Murray }
57113e3f4d6SMark Murray break;
57213e3f4d6SMark Murray }
57313e3f4d6SMark Murray }
57413e3f4d6SMark Murray
57513e3f4d6SMark Murray #endif
57613e3f4d6SMark Murray
57713e3f4d6SMark Murray #ifdef notdef
57813e3f4d6SMark Murray
prkey(msg,key)57913e3f4d6SMark Murray prkey(msg, key)
58013e3f4d6SMark Murray char *msg;
58113e3f4d6SMark Murray unsigned char *key;
58213e3f4d6SMark Murray {
58313e3f4d6SMark Murray int i;
58413e3f4d6SMark Murray printf("%s:", msg);
58513e3f4d6SMark Murray for (i = 0; i < 8; i++)
58613e3f4d6SMark Murray printf(" %3d", key[i]);
587 printf("\r\n");
588 }
589 #endif
590