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
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
|
/*
* rd_req.c
*
* Copyright 1985, 1986, 1987, 1988 by the Massachusetts Institute
* of Technology.
*
* For copying and distribution information, please see the file
* <mit-copyright.h>.
*/
#include "mit-copyright.h"
#include "des.h"
#include "krb.h"
#include "prot.h"
#include <string.h>
#include <krb5.h>
#include <krb54proto.h>
extern int krb_ap_req_debug;
extern char *krb__get_srvtabname();
/* declared in krb.h */
int krb_ignore_ip_address = 0;
/*
* Keep the following information around for subsequent calls
* to this routine by the same server using the same key.
*/
static Key_schedule serv_key; /* Key sched to decrypt ticket */
static C_Block ky; /* Initialization vector */
static int st_kvno; /* version number for this key */
static char st_rlm[REALM_SZ]; /* server's realm */
static char st_nam[ANAME_SZ]; /* service name */
static char st_inst[INST_SZ]; /* server's instance */
static int krb5_key; /* whether krb5 key is used for decrypt */
/*
* This file contains two functions. krb_set_key() takes a DES
* key or password string and returns a DES key (either the original
* key, or the password converted into a DES key) and a key schedule
* for it.
*
* krb_rd_req() reads an authentication request and returns information
* about the identity of the requestor, or an indication that the
* identity information was not authentic.
*/
/*
* krb_set_key() takes as its first argument either a DES key or a
* password string. The "cvt" argument indicates how the first
* argument "key" is to be interpreted: if "cvt" is null, "key" is
* taken to be a DES key; if "cvt" is non-null, "key" is taken to
* be a password string, and is converted into a DES key using
* string_to_key(). In either case, the resulting key is returned
* in the external static variable "ky". A key schedule is
* generated for "ky" and returned in the external static variable
* "serv_key".
*
* This routine returns the return value of des_key_sched.
*
* krb_set_key() needs to be in the same .o file as krb_rd_req() so that
* the key set by krb_set_key() is available in private storage for
* krb_rd_req().
*/
static krb5_keyblock srv_k5key;
int
krb_set_key(key,cvt)
char *key;
int cvt;
{
if (krb5_key)
/* XXX assumes that context arg is ignored */
krb5_free_keyblock_contents(NULL, &srv_k5key);
krb5_key = 0;
#ifdef NOENCRYPTION
memset(ky, 0, sizeof(ky));
return KSUCCESS;
#else /* Encrypt */
if (cvt)
string_to_key(key,ky);
else
memcpy((char *)ky, key, 8);
return(des_key_sched(ky,serv_key));
#endif /* NOENCRYPTION */
}
int
krb_set_key_krb5(ctx, key)
krb5_context ctx;
krb5_keyblock *key;
{
if (krb5_key)
krb5_free_keyblock_contents(ctx, &srv_k5key);
krb5_key = 1;
return krb5_copy_keyblock_contents(ctx, key, &srv_k5key);
}
void
krb_clear_key_krb5(ctx)
krb5_context ctx;
{
if (krb5_key)
krb5_free_keyblock_contents(ctx, &srv_k5key);
krb5_key = 0;
}
/* A helper function to let us see if a buffer is properly terminated. */
static int
krb_strnlen(const char *str, size_t max_len)
{
int i = 0;
for(i = 0; i < max_len; i++) {
if(str[i] == '\0') {
return i;
}
}
return -1;
}
/*
* krb_rd_req() takes an AUTH_MSG_APPL_REQUEST or
* AUTH_MSG_APPL_REQUEST_MUTUAL message created by krb_mk_req(),
* checks its integrity and returns a judgement as to the requestor's
* identity.
*
* The "authent" argument is a pointer to the received message.
* The "service" and "instance" arguments name the receiving server,
* and are used to get the service's ticket to decrypt the ticket
* in the message, and to compare against the server name inside the
* ticket. "from_addr" is the network address of the host from which
* the message was received; this is checked against the network
* address in the ticket. If "from_addr" is zero, the check is not
* performed. "ad" is an AUTH_DAT structure which is
* filled in with information about the sender's identity according
* to the authenticator and ticket sent in the message. Finally,
* "fn" contains the name of the file containing the server's key.
* (If "fn" is NULL, the server's key is assumed to have been set
* by krb_set_key(). If "fn" is the null string ("") the default
* file KEYFILE, defined in "krb.h", is used.)
*
* krb_rd_req() returns RD_AP_OK if the authentication information
* was genuine, or one of the following error codes (defined in
* "krb.h"):
*
* RD_AP_VERSION - wrong protocol version number
* RD_AP_MSG_TYPE - wrong message type
* RD_AP_UNDEC - couldn't decipher the message
* RD_AP_INCON - inconsistencies found
* RD_AP_BADD - wrong network address
* RD_AP_TIME - client time (in authenticator)
* too far off server time
* RD_AP_NYV - Kerberos time (in ticket) too
* far off server time
* RD_AP_EXP - ticket expired
*
* For the message format, see krb_mk_req().
*
* Mutual authentication is not implemented.
*/
KRB5_DLLIMP int KRB5_CALLCONV
krb_rd_req(authent,service,instance,from_addr,ad,fn)
register KTEXT authent; /* The received message */
char FAR *service; /* Service name */
char FAR *instance; /* Service instance */
unsigned KRB4_32 from_addr; /* Net address of originating host */
AUTH_DAT FAR *ad; /* Structure to be filled in */
char FAR *fn; /* Filename to get keys from */
{
KTEXT_ST ticket; /* Temp storage for ticket */
KTEXT tkt = &ticket;
KTEXT_ST req_id_st; /* Temp storage for authenticator */
register KTEXT req_id = &req_id_st;
char realm[REALM_SZ]; /* Realm of issuing kerberos */
Key_schedule seskey_sched; /* Key sched for session key */
unsigned char skey[KKEY_SZ]; /* Session key from ticket */
char sname[SNAME_SZ]; /* Service name from ticket */
char iname[INST_SZ]; /* Instance name from ticket */
char r_aname[ANAME_SZ]; /* Client name from authenticator */
char r_inst[INST_SZ]; /* Client instance from authenticator */
char r_realm[REALM_SZ]; /* Client realm from authenticator */
unsigned int r_time_ms; /* Fine time from authenticator */
unsigned KRB4_32 r_time_sec; /* Coarse time from authenticator */
register char *ptr; /* For stepping through */
unsigned KRB4_32 t_local; /* Local time on our side of the protocol */
KRB4_32 delta_t; /* Time in authenticator minus local time */
KRB4_32 tkt_age; /* Age of ticket */
int swap_bytes; /* Need to swap bytes? */
int mutual; /* Mutual authentication requested? */
unsigned char s_kvno; /* Version number of the server's key
Kerberos used to encrypt ticket */
krb5_keyblock keyblock;
int status;
tkt->mbz = req_id->mbz = 0;
if (authent->length <= 0)
return(RD_AP_MODIFIED);
ptr = (char *) authent->dat;
/* get msg version, type and byte order, and server key version */
/* check version */
if (KRB_PROT_VERSION != (unsigned int) *ptr++)
return(RD_AP_VERSION);
/* byte order */
swap_bytes = 0;
if ((*ptr & 1) != HOST_BYTE_ORDER)
swap_bytes++;
/* check msg type */
mutual = 0;
switch (*ptr++ & ~1) {
case AUTH_MSG_APPL_REQUEST:
break;
case AUTH_MSG_APPL_REQUEST_MUTUAL:
mutual++;
break;
default:
return(RD_AP_MSG_TYPE);
}
#ifdef lint
/* XXX mutual is set but not used; why??? */
/* this is a crock to get lint to shut up */
if (mutual)
mutual = 0;
#endif /* lint */
s_kvno = *ptr++; /* get server key version */
if(krb_strnlen(ptr, sizeof(realm)) < 0) {
return RD_AP_MODIFIED; /* must have been modified, the client wouldn't
try to trick us with wacky data */
}
(void) strncpy(realm,ptr,REALM_SZ); /* And the realm of the issuing KDC */
realm[REALM_SZ-1] = '\0';
ptr += strlen(realm) + 1; /* skip the realm "hint" */
/*
* If "fn" is NULL, key info should already be set; don't
* bother with ticket file. Otherwise, check to see if we
* already have key info for the given server and key version
* (saved in the static st_* variables). If not, go get it
* from the ticket file. If "fn" is the null string, use the
* default ticket file.
*/
if (fn && (strcmp(st_nam,service) || strcmp(st_inst,instance) ||
strcmp(st_rlm,realm) || (st_kvno != s_kvno))) {
if (*fn == 0) fn = KEYFILE;
st_kvno = s_kvno;
#ifndef NOENCRYPTION
if (read_service_key(service,instance,realm,(int) s_kvno,
fn,(char *)skey) == 0) {
if ((status = krb_set_key((char *)skey,0)))
return(status);
#ifdef KRB4_USE_KEYTAB
} else if (krb54_get_service_keyblock(service,instance,
realm, (int) s_kvno,fn, &keyblock) == 0) {
krb_set_key_krb5(krb5__krb4_context, &keyblock);
krb5_free_keyblock_contents(krb5__krb4_context, &keyblock);
#endif
} else
return(RD_AP_UNDEC);
#endif /* !NOENCRYPTION */
(void) strncpy(st_rlm,realm, sizeof(st_rlm) - 1);
st_rlm[sizeof(st_rlm) - 1] = '\0';
(void) strncpy(st_nam,service, sizeof(st_nam) - 1);
st_nam[sizeof(st_nam) - 1] = '\0';
(void) strncpy(st_inst,instance, sizeof(st_inst) - 1);
st_inst[sizeof(st_inst) - 1] = '\0';
}
/* Get ticket from authenticator */
tkt->length = (int) *ptr++ & 0xff;
if ((tkt->length + (ptr+1 - (char *) authent->dat)) > authent->length)
return(RD_AP_MODIFIED);
memcpy((char *)(tkt->dat), ptr+1, tkt->length);
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("ticket->length: %d",tkt->length);
if (krb_ap_req_debug)
log("authent->length: %d", authent->length);
#endif
#ifndef NOENCRYPTION
/* Decrypt and take apart ticket */
#endif
if (!krb5_key) {
if (decomp_ticket(tkt,&ad->k_flags,ad->pname,ad->pinst,ad->prealm,
&(ad->address),ad->session, &(ad->life),
&(ad->time_sec),sname,iname,ky,serv_key)) {
#ifdef KRB_CRYPT_DEBUG
log("Can't decode ticket");
#endif
return(RD_AP_UNDEC);
}
} else {
if (decomp_tkt_krb5(tkt, &ad->k_flags, ad->pname, ad->pinst,
ad->prealm, &ad->address, ad->session,
&ad->life, &ad->time_sec, sname, iname,
&srv_k5key)) {
return RD_AP_UNDEC;
}
}
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug) {
log("Ticket Contents.");
log(" Aname: %s%s%s@%s",ad->pname,
((int)*(ad->pinst) ? "." : ""), ad->pinst,
((int)*(ad->prealm) ? ad->prealm : "Athena"));
log(" Service: %s%s%s",sname,((int)*iname ? "." : ""),iname);
log(" sname=%s, sinst=%s", sname, iname);
}
#endif
/* Extract the authenticator */
req_id->length = (int) *(ptr++);
if ((req_id->length + (ptr + tkt->length - (char *) authent->dat)) >
authent->length)
return(RD_AP_MODIFIED);
memcpy((char *)(req_id->dat), ptr + tkt->length, req_id->length);
#ifndef NOENCRYPTION
/* And decrypt it with the session key from the ticket */
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug) log("About to decrypt authenticator");
#endif
key_sched(ad->session,seskey_sched);
pcbc_encrypt((C_Block *)req_id->dat,(C_Block *)req_id->dat,
(long) req_id->length, seskey_sched,&ad->session,DES_DECRYPT);
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug) log("Done.");
#endif
#endif /* NOENCRYPTION */
#define check_ptr() if ((ptr - (char *) req_id->dat) > req_id->length) return(RD_AP_MODIFIED);
ptr = (char *) req_id->dat;
(void) strncpy(r_aname,ptr,ANAME_SZ); /* Authentication name */
r_aname[ANAME_SZ-1] = '\0';
ptr += strlen(r_aname)+1;
check_ptr();
(void) strncpy(r_inst,ptr,INST_SZ); /* Authentication instance */
r_inst[INST_SZ-1] = '\0';
ptr += strlen(r_inst)+1;
check_ptr();
(void) strncpy(r_realm,ptr,REALM_SZ); /* Authentication name */
r_realm[REALM_SZ-1] = '\0';
ptr += strlen(r_realm)+1;
check_ptr();
memcpy((char *)&ad->checksum, ptr, 4); /* Checksum */
ptr += 4;
check_ptr();
if (swap_bytes) ad->checksum = krb4_swab32(ad->checksum);
r_time_ms = *(ptr++); /* Time (fine) */
#ifdef lint
/* XXX r_time_ms is set but not used. why??? */
/* this is a crock to get lint to shut up */
if (r_time_ms)
r_time_ms = 0;
#endif /* lint */
check_ptr();
/* assume sizeof(r_time_sec) == 4 ?? */
memcpy((char *)&r_time_sec, ptr, 4); /* Time (coarse) */
if (swap_bytes) r_time_sec = krb4_swab32(r_time_sec);
/* Check for authenticity of the request */
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("Pname: %s %s",ad->pname,r_aname);
#endif
if (strcmp(ad->pname,r_aname) != 0)
return(RD_AP_INCON);
if (strcmp(ad->pinst,r_inst) != 0)
return(RD_AP_INCON);
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("Realm: %s %s",ad->prealm,r_realm);
#endif
if ((strcmp(ad->prealm,r_realm) != 0))
return(RD_AP_INCON);
/* check the time integrity of the msg */
t_local = TIME_GMT_UNIXSEC;
delta_t = t_local - r_time_sec;
if (delta_t < 0) delta_t = -delta_t; /* Absolute value of difference */
if (delta_t > CLOCK_SKEW) {
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("Time out of range: %d - %d = %d",
time_secs, r_time_sec, delta_t);
#endif
return(RD_AP_TIME);
}
/* Now check for expiration of ticket */
tkt_age = t_local - ad->time_sec;
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("Time: %d Issue Date: %d Diff: %d Life %x",
time_secs, ad->time_sec, tkt_age, ad->life);
#endif
if (t_local < ad->time_sec) {
if ((ad->time_sec - t_local) > CLOCK_SKEW)
return(RD_AP_NYV);
}
else if ((t_local - ad->time_sec) > 5 * 60 * ad->life)
return(RD_AP_EXP);
#ifdef KRB_CRYPT_DEBUG
if (krb_ap_req_debug)
log("Address: %d %d",ad->address,from_addr);
#endif
if (!krb_ignore_ip_address && from_addr && (ad->address != from_addr))
return(RD_AP_BADD);
/* All seems OK */
ad->reply.length = 0;
return(RD_AP_OK);
}
|