1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
/*
* recvauth.c
*
* Copyright 1987, 1988 by the Massachusetts Institute of Technology.
*
* For copying and distribution information, please see the file
* <mit-copyright.h>.
*/
#include "mit-copyright.h"
#define DEFINE_SOCKADDR /* Ask for sockets declarations from krb.h. */
#include "krb.h"
#include <errno.h>
#include <stdio.h>
#include <string.h>
#define KRB_SENDAUTH_VERS "AUTHV0.1" /* MUST be KRB_SENDAUTH_VLEN
chars */
/*
* If the protocol changes, you will need to change the version string
* and make appropriate changes in krb_sendauth.c
* be sure to support old versions of krb_sendauth!
*/
#ifndef _WINDOWS
extern int errno;
#endif
/*
* krb_recvauth() reads (and optionally responds to) a message sent
* using krb_sendauth(). The "options" argument is a bit-field of
* selected options (see "sendauth.c" for options description).
* The only option relevant to krb_recvauth() is KOPT_DO_MUTUAL
* (mutual authentication requested). The "fd" argument supplies
* a file descriptor to read from (and write to, if mutual authenti-
* cation is requested).
*
* Part of the received message will be a Kerberos ticket sent by the
* client; this is read into the "ticket" argument. The "service" and
* "instance" arguments supply the server's Kerberos name. If the
* "instance" argument is the string "*", it is treated as a wild card
* and filled in during the krb_rd_req() call (see read_service_key()).
*
* The "faddr" and "laddr" give the sending (client) and receiving
* (local server) network addresses. ("laddr" may be left NULL unless
* mutual authentication is requested, in which case it must be set.)
*
* The authentication information extracted from the message is returned
* in "kdata". The "filename" argument indicates the file where the
* server's key can be found. (It is passed on to krb_rd_req().) If
* left null, the default "/etc/srvtab" will be used.
*
* If mutual authentication is requested, the session key schedule must
* be computed in order to reply; this schedule is returned in the
* "schedule" argument. A string containing the application version
* number from the received message is returned in "version", which
* should be large enough to hold a KRB_SENDAUTH_VLEN-character string.
*
* See krb_sendauth() for the format of the received client message.
*
* This routine supports another client format, for backward
* compatibility, consisting of:
*
* Size Variable Field
* ---- -------- -----
*
* string tmp_buf, tkt_len length of ticket, in
* ascii
*
* char ' ' (space char) separator
*
* tkt_len ticket->dat the ticket
*
* This old-style version does not support mutual authentication.
*
* krb_recvauth() first reads the protocol version string from the
* given file descriptor. If it doesn't match the current protocol
* version (KRB_SENDAUTH_VERS), the old-style format is assumed. In
* that case, the string of characters up to the first space is read
* and interpreted as the ticket length, then the ticket is read.
*
* If the first string did match KRB_SENDAUTH_VERS, krb_recvauth()
* next reads the application protocol version string. Then the
* ticket length and ticket itself are read.
*
* The ticket is decrypted and checked by the call to krb_rd_req().
* If no mutual authentication is required, the result of the
* krb_rd_req() call is retured by this routine. If mutual authenti-
* cation is required, a message in the following format is returned
* on "fd":
*
* Size Variable Field
* ---- -------- -----
*
* 4 bytes tkt_len length of ticket or -1
* if error occurred
*
* priv_len tmp_buf "private" message created
* by krb_mk_priv() which
* contains the incremented
* checksum sent by the client
* encrypted in the session
* key. (This field is not
* present in case of error.)
*
* If all goes well, KSUCCESS is returned; otherwise KFAILURE or some
* other error code is returned.
*/
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif /* max */
KRB5_DLLIMP int KRB5_CALLCONV
krb_recvauth(options, fd, ticket, service, instance, faddr, laddr, kdata,
filename, schedule, version)
long options; /* bit-pattern of options */
int fd; /* file descr. to read from */
KTEXT ticket; /* storage for client's ticket */
char FAR *service; /* service expected */
char FAR *instance; /* inst expected (may be filled in) */
struct sockaddr_in FAR *faddr; /* address of foreign host on fd */
struct sockaddr_in FAR *laddr; /* local address */
AUTH_DAT FAR *kdata; /* kerberos data (returned) */
char FAR *filename; /* name of file with service keys */
Key_schedule schedule; /* key schedule (return) */
char FAR *version; /* version string (filled in) */
{
int i, cc, old_vers = 0;
char krb_vers[KRB_SENDAUTH_VLEN + 1]; /* + 1 for the null terminator */
char *cp;
int rem;
KRB4_32 tkt_len, priv_len;
unsigned KRB4_32 cksum;
u_char tmp_buf[MAX_KTXT_LEN+max(KRB_SENDAUTH_VLEN+1,21)];
/* read the protocol version number */
if (krb_net_read(fd, krb_vers, KRB_SENDAUTH_VLEN) !=
KRB_SENDAUTH_VLEN)
return(errno);
krb_vers[KRB_SENDAUTH_VLEN] = '\0';
/* check version string */
if (strcmp(krb_vers,KRB_SENDAUTH_VERS)) {
/* Assume the old version of sendkerberosdata: send ascii
length, ' ', and ticket. */
if (options & KOPT_DO_MUTUAL)
return(KFAILURE); /* XXX can't do old style with mutual auth */
old_vers = 1;
/* copy what we have read into tmp_buf */
(void) memcpy((char *) tmp_buf, krb_vers, KRB_SENDAUTH_VLEN);
/* search for space, and make it a null */
for (i = 0; i < KRB_SENDAUTH_VLEN; i++)
if (tmp_buf[i]== ' ') {
tmp_buf[i] = '\0';
/* point cp to the beginning of the real ticket */
cp = (char *) &tmp_buf[i+1];
break;
}
if (i == KRB_SENDAUTH_VLEN)
/* didn't find the space, keep reading to find it */
for (; i<20; i++) {
if (read(fd, (char *)&tmp_buf[i], 1) != 1) {
return(KFAILURE);
}
if (tmp_buf[i] == ' ') {
tmp_buf[i] = '\0';
/* point cp to the beginning of the real ticket */
cp = (char *) &tmp_buf[i+1];
break;
}
}
tkt_len = (KRB4_32) atoi((char *) tmp_buf);
/* sanity check the length */
/* These conditions make sure that cp got initialized */
if ((i==20)||(tkt_len<=0)||(tkt_len>MAX_KTXT_LEN))
return(KFAILURE);
if (i < KRB_SENDAUTH_VLEN) {
/* since we already got the space, and part of the ticket,
we read fewer bytes to get the rest of the ticket */
if (krb_net_read(fd, (char *)(tmp_buf+KRB_SENDAUTH_VLEN),
(int) (tkt_len - KRB_SENDAUTH_VLEN + 1 + i))
!= (int)(tkt_len - KRB_SENDAUTH_VLEN + 1 + i))
return(errno);
} else {
if (krb_net_read(fd, (char *)(tmp_buf+i), (int)tkt_len) !=
(int) tkt_len)
return(errno);
}
ticket->length = tkt_len;
/* copy the ticket into the struct */
(void) memcpy((char *) ticket->dat, cp, ticket->length);
} else {
/* read the application version string */
if (krb_net_read(fd, version, KRB_SENDAUTH_VLEN) !=
KRB_SENDAUTH_VLEN)
return(errno);
version[KRB_SENDAUTH_VLEN] = '\0';
/* get the length of the ticket */
if (krb_net_read(fd, (char *)&tkt_len, sizeof(tkt_len)) !=
sizeof(tkt_len))
return(errno);
/* sanity check */
ticket->length = ntohl((unsigned KRB4_32)tkt_len);
if ((ticket->length <= 0) || (ticket->length > MAX_KTXT_LEN)) {
if (options & KOPT_DO_MUTUAL) {
rem = KFAILURE;
goto mutual_fail;
} else
return(KFAILURE); /* XXX there may still be junk on the fd? */
}
/* read the ticket */
if (krb_net_read(fd, (char *) ticket->dat, ticket->length)
!= ticket->length)
return(errno);
}
/*
* now have the ticket. decrypt it to get the authenticated
* data.
*/
rem = krb_rd_req(ticket,service,instance,faddr->sin_addr.s_addr,
kdata,filename);
if (old_vers) return(rem); /* XXX can't do mutual with old client */
/* if we are doing mutual auth, compose a response */
if (options & KOPT_DO_MUTUAL) {
if (rem != KSUCCESS)
/* the krb_rd_req failed */
goto mutual_fail;
/* add one to the (formerly) sealed checksum, and re-seal it
for return to the client */
cksum = kdata->checksum + 1;
cksum = htonl(cksum);
#ifndef NOENCRYPTION
key_sched(kdata->session,schedule);
#endif /* !NOENCRYPTION */
priv_len = krb_mk_priv((unsigned char *)&cksum,
tmp_buf,
(unsigned KRB4_32) sizeof(cksum),
schedule,
kdata->session,
laddr,
faddr);
if (priv_len < 0) {
/* re-sealing failed; notify the client */
rem = KFAILURE; /* XXX */
mutual_fail:
priv_len = -1;
tkt_len = htonl((unsigned KRB4_32) priv_len);
/* a length of -1 is interpreted as an authentication
failure by the client */
if ((cc = krb_net_write(fd, (char *)&tkt_len, sizeof(tkt_len)))
!= sizeof(tkt_len))
return(cc);
return(rem);
} else {
/* re-sealing succeeded, send the private message */
tkt_len = htonl((unsigned KRB4_32)priv_len);
if ((cc = krb_net_write(fd, (char *)&tkt_len, sizeof(tkt_len)))
!= sizeof(tkt_len))
return(cc);
if ((cc = krb_net_write(fd, (char *)tmp_buf, (int) priv_len))
!= (int) priv_len)
return(cc);
}
}
return(rem);
}
|