?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge 1.8.0~pre4 packaging into master
[pkg-k5-afs_openafs.git] / src / kauth / kaprocs.c
blob315096a46197edfdcc31cda70b698eb8bcc4e434
1 /*
2 * Copyright 2000, International Business Machines Corporation and others.
3 * All Rights Reserved.
4 *
5 * This software has been released under the terms of the IBM Public
6 * License. For details, see the LICENSE file in the top-level source
7 * directory or online at http://www.openafs.org/dl/license10.html
8 */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <roken.h>
15 #include <afs/opr.h>
16
17 #ifdef HAVE_SYS_RESOURCE_H
18 # include <sys/resource.h>
19 #endif
20
21 #ifdef IGNORE_SOME_GCC_WARNINGS
22 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
23 #endif
24
25 #include "kauth.h"
26
27 #define HC_DEPRECATED
28 #include <hcrypto/des.h>
29
30 #include <lock.h>
31 #include <ubik.h>
32 #include <lwp.h>
33 #include <rx/xdr.h>
34 #include <rx/rx.h>
35 #include <rx/rxkad.h>
36 #include <rx/rxkad_convert.h>
37 #include <afs/cellconfig.h>
38 #include <afs/auth.h>
39 #include <afs/com_err.h>
40 #include <afs/afsutil.h>
41 #include <afs/audit.h>
42
43 #include "kautils.h"
44 #include "kaserver.h"
45 #include "kalog.h"
46 #include "kaport.h"
47 #include "kauth_internal.h"
48
49 #include "kadatabase.h"
50 #include "kaprocs.h"
51
52 extern struct ubik_dbase *KA_dbase;
53 struct kaheader cheader;
54 Date cheaderReadTime; /* time cheader last read in */
55 extern struct afsconf_dir *KA_conf; /* for getting cell info */
56
57
58
59 char lrealm[MAXKTCREALMLEN];
60
61 #ifndef EXPIREPW /* password expiration default yes */
62 #define EXPIREPW
63 #endif
64
65 #ifndef AUTOCPWINTERVAL
66 #define AUTOCPWINTERVAL (24*3600)
67 #endif
68 #ifndef AUTOCPWUPDATES
69 #define AUTOCPWUPDATES 128
70 #endif
71
72 extern int npwSums;
73
74 static afs_int32 autoCPWInterval;
75 static afs_int32 autoCPWUpdates;
76
77 static afs_int32 set_password(struct ubik_trans *tt, char *name,
78 char *instance,
79 struct ktc_encryptionKey *password,
80 afs_int32 kvno, afs_int32 caller);
81 static afs_int32 impose_reuse_limits(EncryptionKey *password,
82 struct kaentry *tentry);
83 static int create_user(struct ubik_trans *tt, char *name, char *instance,
84 struct ktc_encryptionKey *key, afs_int32 caller,
85 afs_int32 flags);
86
87 /* This routine is called whenever an RPC interface needs the time. It uses
88 the current time to randomize a 128 bit value that is used to change the
89 AuthServer Admin and TGS keys automatically. */
90
91 static Date nextAutoCPWTime = 0;
92 static afs_int32 totalUpdates = 0;
93
94 /* This routine is ostensibly to get the current time, but basically its job is
95 to periodically update a random number. It also periodically updates the
96 keys for the builtin servers. This is why it needs a transaction pointer
97 and returns an error code. If the caller is in a read transaction, the tt
98 ptr should be zero and the return code need not be checked. */
99
100 static afs_int32
101 get_time(Date *timeP,
102 struct ubik_trans *tt, /* tt != 0: a write transaction */
103 int admin) /* the caller is an admin user */
104 {
105 /* random value used to change Admin & TGS keys, this is at risk during
106 * multi-threaded operation, but I think the consequences are fairly
107 * harmless. */
108 static afs_uint32 random_value[4];
109
110 struct timeval time;
111 unsigned int bit, nbit;
112 int i;
113 afs_int32 to;
114
115 gettimeofday(&time, NULL);
116 bit = (random_value[3] >> 31) & 1; /* get high bit of high word */
117 for (i = 0; i < 4; i++) {
118 nbit = random_value[i] >> 31;
119 random_value[i] = (random_value[i] << 1) + bit;
120 bit = nbit & 1;
121 }
122 /* get 60ths from usec. This is all the real randomness there is. */
123 random_value[0] += time.tv_usec / 16667;
124
125 if (nextAutoCPWTime == 0) { /* initialize things */
126 nextAutoCPWTime = time.tv_sec + autoCPWInterval;
127 memcpy(&random_value[0], &time, 8);
128 memcpy(&random_value[2], &time, 8);
129 }
130
131 if ((++totalUpdates >= autoCPWUpdates) && tt && /* a write transaction */
132 ((admin && (time.tv_sec >= nextAutoCPWTime))
133 || (time.tv_sec >= nextAutoCPWTime + autoCPWInterval))) {
134 struct ktc_encryptionKey key;
135 char buf[4 * sizeof(key) + 1];
136 struct kaentry tentry;
137 afs_int32 code;
138 char bob[KA_TIMESTR_LEN];
139
140 ka_timestr(time.tv_sec, bob, KA_TIMESTR_LEN);
141 es_Report("Auto CPW at %s\n", bob);
142 if (!admin)
143 es_Report(" ... even though no ADMIN user\n");
144
145 code = FindBlock(tt, KA_ADMIN_NAME, KA_ADMIN_INST, &to, &tentry);
146 if (code)
147 return code;
148 if (to) { /* check if auto cpw is disabled */
149 if (!(ntohl(tentry.flags) & KAFNOCPW)) {
150 memcpy(&key, &random_value[0], sizeof(key));
151 DES_set_odd_parity(ktc_to_cblock(&key));
152 code =
153 set_password(tt, KA_ADMIN_NAME, KA_ADMIN_INST, &key, 0,
154 0);
155 if (code == 0) {
156 DES_init_random_number_generator(ktc_to_cblock(&key));
157 ka_ConvertBytes(buf, sizeof(buf), (char *)&key,
158 sizeof(key));
159 es_Report("New Admin key is %s\n", buf);
160 } else {
161 es_Report
162 ("in get_time: set_password failed because: %d\n",
163 code);
164 return code;
165 }
166 }
167 }
168
169 code = FindBlock(tt, KA_TGS_NAME, lrealm, &to, &tentry);
170 if (code)
171 return code;
172 if (to) { /* check if auto cpw is disabled */
173 if (!(ntohl(tentry.flags) & KAFNOCPW)) {
174 memcpy(&key, &random_value[2], sizeof(key));
175 DES_set_odd_parity(ktc_to_cblock(&key));
176 code = set_password(tt, KA_TGS_NAME, lrealm, &key, 0, 0);
177 if (code == 0) {
178 ka_ConvertBytes(buf, sizeof(buf), (char *)&key,
179 sizeof(key));
180 es_Report("New TGS key is %s\n", buf);
181 } else {
182 es_Report
183 ("in get_time: set_password failed because: %s\n",
184 afs_error_message(code));
185 return code;
186 }
187 }
188 }
189 code = ka_FillKeyCache(tt); /* ensure in-core copy is uptodate */
190 if (code)
191 return code;
192
193 nextAutoCPWTime = time.tv_sec + autoCPWInterval;
194 totalUpdates = 0;
195 }
196 if (timeP)
197 *timeP = time.tv_sec;
198 return 0;
199 }
200
201 static int noAuthenticationRequired; /* global state */
202 static int recheckNoAuth; /* global state */
203
204 /* kaprocsInited is sort of a lock: during a transaction only one process runs
205 while kaprocsInited is false. */
206
207 static int kaprocsInited = 0;
208
209 /* This variable is protected by the kaprocsInited flag. */
210
211 static int (*rebuildDatabase) (struct ubik_trans *);
212
213 /* This is called to initialize the database */
214
215 static int
216 initialize_database(struct ubik_trans *tt)
217 {
218 struct ktc_encryptionKey key;
219 int code;
220
221 gettimeofday((struct timeval *)&key, NULL); /* this is just a cheap seed key */
222 DES_set_odd_parity(ktc_to_cblock(&key));
223 DES_init_random_number_generator(ktc_to_cblock(&key));
224 if ((code = DES_new_random_key(ktc_to_cblock(&key)))
225 || (code =
226 create_user(tt, KA_ADMIN_NAME, KA_ADMIN_INST, &key, 0,
227 KAFNORMAL | KAFNOSEAL | KAFNOTGS)))
228 return code;
229 if ((code = DES_new_random_key(ktc_to_cblock(&key)))
230 || (code =
231 create_user(tt, KA_TGS_NAME, lrealm, &key, 0,
232 KAFNORMAL | KAFNOSEAL | KAFNOTGS)))
233 return code;
234 return 0;
235 }
236
237 /* This routine handles initialization required by this module. The initFlags
238 parameter passes some information about the command line arguments. */
239
240 afs_int32
241 init_kaprocs(const char *lclpath, int initFlags)
242 {
243 int code;
244 struct ubik_trans *tt;
245 struct ktc_encryptionKey key;
246 afs_int32 kvno;
247
248 kaprocsInited = 0;
249 if (myHost == 0)
250 return KAINTERNALERROR;
251 if (KA_conf == 0)
252 return KAINTERNALERROR;
253 code = afsconf_GetLocalCell(KA_conf, lrealm, sizeof(lrealm));
254 if (code) {
255 printf("** Can't determine local cell name!\n");
256 return KANOCELLS;
257 }
258 ucstring(lrealm, lrealm, sizeof(lrealm));
259
260 recheckNoAuth = 1;
261 if (initFlags & 1)
262 noAuthenticationRequired = 1;
263 if (initFlags & 2)
264 recheckNoAuth = 0;
265 if (recheckNoAuth)
266 noAuthenticationRequired = afsconf_GetNoAuthFlag(KA_conf);
267 if (noAuthenticationRequired)
268 printf("Running server with security disabled\n");
269
270 if (initFlags & 4) {
271 autoCPWInterval = 10;
272 autoCPWUpdates = 10;
273 } else {
274 autoCPWInterval = AUTOCPWINTERVAL;
275 autoCPWUpdates = AUTOCPWUPDATES;
276 }
277
278 init_kadatabase(initFlags);
279 rebuildDatabase = initialize_database;
280
281 if ((code = InitAuthServ(&tt, LOCKREAD, 0))) {
282 printf("init_kaprocs: InitAuthServ failed: code = %d\n", code);
283 return code;
284 }
285 code = ka_LookupKey(tt, KA_ADMIN_NAME, KA_ADMIN_INST, &kvno, &key);
286 if (code) {
287 ubik_AbortTrans(tt);
288 printf
289 ("init_kaprocs: ka_LookupKey (code = %d) DB not initialized properly?\n",
290 code);
291 return code;
292 }
293 DES_init_random_number_generator(ktc_to_cblock(&key));
294
295 code = ubik_EndTrans(tt);
296 if (code) {
297 printf("init_kaprocs: ubik_EndTrans failed: code = %d\n", code);
298 return code;
299 }
300
301 kaux_opendb((char *)lclpath);/* aux database stores failure counters */
302 rebuildDatabase = 0; /* only do this during init */
303 kaprocsInited = 1;
304 return 0;
305 }
306
307 /* These variable are for returning debugging info about the state of the
308 server. If they get trashed during multi-threaded operation it doesn't
309 matter. */
310
311 /* this is global so COUNT_REQ in krb_udp.c can refer to it. */
312 char *lastOperation = 0; /* name of last operation */
313 static Date lastTrans; /* time of last transaction */
314
315 static char adminPrincipal[256];
316 static char authPrincipal[256];
317 static char tgsPrincipal[256];
318 static char tgsServerPrincipal[256];
319
320 void
321 save_principal(char *p, char *n, char *i, char *c)
322 {
323 int s = 255;
324 int l;
325
326 l = strlen(n);
327 if (l > s)
328 return;
329 strcpy(p, n);
330 s -= l;
331 if (i && strlen(i)) {
332 if (s-- <= 0)
333 return;
334 strcat(p, ".");
335 l = strlen(i);
336 if (l > s)
337 return;
338 strcat(p, i);
339 s -= l;
340 }
341 if (c && strlen(c)) {
342 if (s-- <= 0)
343 return;
344 strcat(p, "@");
345 l = strlen(c);
346 if (l > s)
347 return;
348 strcat(p, c);
349 }
350 }
351
352 static afs_int32
353 check_auth(struct rx_call *call,
354 struct ubik_trans *at,
355 int admin, /* require caller to be ADMIN */
356 afs_int32 *acaller_id)
357 {
358 rxkad_level level;
359 char name[MAXKTCNAMELEN];
360 char instance[MAXKTCNAMELEN];
361 char cell[MAXKTCREALMLEN];
362 afs_int32 kvno;
363 Date expiration; /* checked by Security Module */
364 struct kaentry tentry;
365 int code;
366 int si;
367
368 *acaller_id = 0;
369
370 if (recheckNoAuth)
371 noAuthenticationRequired = afsconf_GetNoAuthFlag(KA_conf);
372
373 si = rx_SecurityClassOf(rx_ConnectionOf(call));
374 if (si == RX_SECIDX_VAB) {
375 printf("No support for VAB security module yet.\n");
376 return -1;
377 } else if (si == RX_SECIDX_NULL) {
378 code = KANOAUTH;
379 goto no_auth;
380 } else if (si != RX_SECIDX_KAD) {
381 es_Report("Unknown security index %d\n", si);
382 return -1;
383 }
384
385 code =
386 rxkad_GetServerInfo(rx_ConnectionOf(call), &level, &expiration, name,
387 instance, cell, &kvno);
388 if (code) {
389 goto no_auth;
390 }
391 if (level != rxkad_crypt) {
392 es_Report("Incorrect security level = %d\n", level);
393 code = KANOAUTH;
394 goto no_auth;
395 }
396
397 if (!name_instance_legal(name, instance))
398 return KABADNAME;
399 if (strlen(cell)) {
400 ka_PrintUserID
401 ("Authorization rejected because we don't understand intercell stuff yet: ",
402 name, instance, "");
403 printf("@%s\n", cell);
404 return KANOAUTH;
405 }
406
407 code = FindBlock(at, name, instance, acaller_id, &tentry);
408 if (code)
409 return code;
410 if (*acaller_id == 0) {
411 ka_PrintUserID("User ", name, instance, " unknown.\n");
412 return KANOENT;
413 }
414 save_principal(adminPrincipal, name, instance, 0);
415
416 if (admin) {
417 if (!(ntohl(tentry.flags) & KAFADMIN)) {
418 if (noAuthenticationRequired) {
419 ka_PrintUserID("Authorization approved for ", name, instance,
420 " because there is no authentication required\n");
421 osi_auditU(call, UnAuthEvent, code, AUD_STR, name, AUD_STR,
422 instance, AUD_STR, cell, AUD_END);
423 return 0;
424 }
425 ka_PrintUserID("User ", name, instance, " is not ADMIN.\n");
426 return KANOAUTH;
427 }
428 osi_auditU(call, UseOfPrivilegeEvent, code, AUD_STR, name, AUD_STR,
429 instance, AUD_STR, cell, AUD_END);
430 }
431 return 0;
432
433 no_auth:
434 if (noAuthenticationRequired) {
435 es_Report
436 ("Caller w/o authorization approved no authentication required\n");
437 osi_auditU(call, UnAuthEvent, code, AUD_STR, name, AUD_STR, instance,
438 AUD_STR, cell, AUD_END);
439 return 0;
440 }
441 return code; /* no auth info */
442 }
443
444 afs_int32
445 AwaitInitialization(void)
446 {
447 afs_int32 start = 0;
448 while (!kaprocsInited) {
449 if (!start)
450 start = time(0);
451 else if (time(0) - start > 5)
452 return UNOQUORUM;
453 IOMGR_Sleep(1);
454 }
455 return 0;
456 }
457
458 /* This is called by every RPC interface to create a Ubik transaction and read
459 the database header into core */
460
461 afs_int32
462 InitAuthServ(struct ubik_trans **tt,
463 int lock, /* indicate read/write transaction */
464 int *this_op) /* opcode of RPC proc, for COUNT_ABO */
465 {
466 int code;
467 afs_int32 start = 0; /* time started waiting for quorum */
468 float wait = 0.91; /* start waiting for 1 second */
469
470 /* Wait for server initialization to finish if not during init_kaprocs */
471 if (this_op)
472 if ((code = AwaitInitialization()))
473 return code;
474
475 for (code = UNOQUORUM; code == UNOQUORUM;) {
476 if (lock == LOCKREAD)
477 code = ubik_BeginTransReadAny(KA_dbase, UBIK_READTRANS, tt);
478 else
479 code = ubik_BeginTrans(KA_dbase, UBIK_WRITETRANS, tt);
480 if (code == UNOQUORUM) { /* no quorum elected */
481 if (!start)
482 start = time(0);
483 else {
484 int delay = time(0) - start;
485 if (this_op) { /* punt quickly, if RPC call */
486 if (delay > 5)
487 return code;
488 } else { /* more patient during init. */
489 if (delay > 500)
490 return code;
491 }
492 }
493 printf("Waiting for quorum election.\n");
494 if (wait < 15.0)
495 wait *= 1.1;
496 IOMGR_Sleep((int)wait);
497 }
498 }
499 if (code)
500 return code;
501 if ((code = ubik_SetLock(*tt, 1, 1, lock))) {
502 if (this_op)
503 COUNT_ABO;
504 ubik_AbortTrans(*tt);
505 return code;
506 }
507 /* check that dbase is initialized and setup cheader */
508 if (lock == LOCKREAD) {
509 /* init but don't fix because this is read only */
510 code = CheckInit(*tt, 0);
511 if (code) {
512 ubik_AbortTrans(*tt); /* abort, since probably I/O error */
513 /* we did the check under a ReadAny transaction, but now, after
514 * getting a write transaction (and thus some real guarantees
515 * about what databases are really out there), we will check again
516 * in CheckInit before nuking the database. Since this may now get
517 * a UNOQUORUM we'll just do this from the top.
518 */
519 if ((code = InitAuthServ(tt, LOCKWRITE, this_op)))
520 return code;
521 if ((code = ubik_EndTrans(*tt)))
522 return code;
523
524 /* now open the read transaction that was originally requested. */
525 return InitAuthServ(tt, lock, this_op);
526 }
527 } else {
528 if ((code = CheckInit(*tt, rebuildDatabase))) {
529 if (this_op)
530 COUNT_ABO;
531 ubik_AbortTrans(*tt);
532 return code;
533 }
534 }
535 lastTrans = time(0);
536 ka_FillKeyCache(*tt); /* ensure in-core copy is uptodate */
537 return 0;
538 }
539
540 /* returns true if name is specially known by AuthServer */
541
542 static int
543 special_name(char *name, char *instance)
544
545 {
546 return ((!strcmp(name, KA_TGS_NAME) && !strcmp(instance, lrealm))
547 || (strcmp(name, KA_ADMIN_NAME) == 0));
548 }
549
550 static int
551 create_user(struct ubik_trans *tt, char *name, char *instance,
552 struct ktc_encryptionKey *key, afs_int32 caller,
553 afs_int32 flags)
554 {
555 int code;
556 afs_int32 to;
557 struct kaentry tentry;
558 afs_int32 maxLifetime;
559
560 code = FindBlock(tt, name, instance, &to, &tentry);
561 if (code)
562 return code;
563 if (to)
564 return KAEXIST; /* name already exists, we fail */
565
566 to = AllocBlock(tt, &tentry);
567 if (to == 0)
568 return KACREATEFAIL;
569
570 /* otherwise we have a block */
571 strncpy(tentry.userID.name, name, sizeof(tentry.userID.name));
572 strncpy(tentry.userID.instance, instance, sizeof(tentry.userID.instance));
573 tentry.flags = htonl(flags);
574 if (special_name(name, instance)) { /* this overrides key & version */
575 tentry.flags = htonl(ntohl(tentry.flags) | KAFSPECIAL);
576 tentry.key_version = htonl(-1); /* don't save this key */
577 if ((code = ka_NewKey(tt, to, &tentry, key)))
578 return code;
579 } else {
580 memcpy(&tentry.key, key, sizeof(tentry.key));
581 tentry.key_version = htonl(0);
582 }
583 tentry.user_expiration = htonl(NEVERDATE);
584 code = get_time(&tentry.modification_time, tt, 1);
585 if (code)
586 return code;
587
588 /* time and addr of entry for guy changing this entry */
589 tentry.modification_time = htonl(tentry.modification_time);
590 tentry.modification_id = htonl(caller);
591 tentry.change_password_time = tentry.modification_time;
592
593 if (strcmp(name, KA_TGS_NAME) == 0)
594 maxLifetime = MAXKTCTICKETLIFETIME;
595 else if (strcmp(name, KA_ADMIN_NAME) == 0)
596 maxLifetime = 10 * 3600;
597 else if (strcmp(name, AUTH_SUPERUSER) == 0)
598 maxLifetime = 100 * 3600;
599 else
600 maxLifetime = 25 * 3600; /* regular users */
601 tentry.max_ticket_lifetime = htonl(maxLifetime);
602
603 code = ThreadBlock(tt, to, &tentry);
604 return code;
605 }
606
607 /* Put actual stub routines here */
608
609 afs_int32
610 SKAM_CreateUser(struct rx_call *call, char *aname, char *ainstance,
611 EncryptionKey ainitpw)
612 {
613 afs_int32 code;
614
615 code = kamCreateUser(call, aname, ainstance, ainitpw);
616 osi_auditU(call, AFS_KAM_CrUserEvent, code, AUD_STR, aname, AUD_STR,
617 ainstance, AUD_END);
618 return code;
619 }
620
621
622 afs_int32
623 kamCreateUser(struct rx_call *call, char *aname, char *ainstance,
624 EncryptionKey ainitpw)
625 {
626 int code;
627 struct ubik_trans *tt;
628 afs_int32 caller; /* Disk offset of caller's entry */
629
630 COUNT_REQ(CreateUser);
631 if (!DES_check_key_parity(EncryptionKey_to_cblock(&ainitpw)) ||
632 DES_is_weak_key(EncryptionKey_to_cblock(&ainitpw)))
633 return KABADKEY;
634 if (!name_instance_legal(aname, ainstance))
635 return KABADNAME;
636 if ((code = InitAuthServ(&tt, LOCKWRITE, this_op)))
637 return code;
638 code = check_auth(call, tt, 1, &caller);
639 if (code) {
640 COUNT_ABO;
641 ubik_AbortTrans(tt);
642 return code;
643 }
644 code = create_user(tt, aname, ainstance, EncryptionKey_to_ktc(&ainitpw), caller, KAFNORMAL);
645 if (code) {
646 COUNT_ABO;
647 ubik_AbortTrans(tt);
648 return code;
649 }
650 code = ubik_EndTrans(tt);
651 KALOG(aname, ainstance, NULL, NULL, NULL,
652 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_CRUSER);
653 return code;
654 }
655
656 afs_int32
657 SKAA_ChangePassword(struct rx_call *call, char *aname, char *ainstance,
658 ka_CBS *arequest, ka_BBS *oanswer)
659 {
660 afs_int32 code;
661
662 code = ChangePassWord(call, aname, ainstance, arequest, oanswer);
663 osi_auditU(call, AFS_KAA_ChPswdEvent, code, AUD_STR, aname, AUD_STR,
664 ainstance, AUD_END);
665 return code;
666 }
667
668 afs_int32
669 ChangePassWord(struct rx_call *call, char *aname, char *ainstance,
670 ka_CBS *arequest, ka_BBS *oanswer)
671 {
672 int code;
673 struct ubik_trans *tt;
674 afs_int32 to; /* offset of block */
675 struct kaentry tentry;
676 struct ka_cpwRequest request; /* request after decryption */
677 char *answer; /* where answer is to be put */
678 int answer_len; /* length of answer packet */
679 afs_int32 kvno; /* requested key version number */
680 DES_key_schedule user_schedule; /* key schedule for user's key */
681 Date request_time; /* time request originated */
682
683 COUNT_REQ(ChangePassword);
684 if (!name_instance_legal(aname, ainstance))
685 return KABADNAME;
686 if (strcmp(ainstance, KA_ADMIN_NAME) == 0)
687 return KABADNAME;
688 if ((code = InitAuthServ(&tt, LOCKWRITE, this_op)))
689 return code;
690
691 code = FindBlock(tt, aname, ainstance, &to, &tentry);
692 if (code) {
693 goto abort;
694 }
695 if (to == 0) { /* no such user */
696 code = KANOENT;
697 goto abort;
698 }
699 if (ntohl(tentry.flags) & KAFNOCPW) {
700 code = KABADCPW;
701 goto abort;
702 }
703
704 /* decrypt request w/ user password */
705 if ((code = DES_key_sched(ktc_to_cblock(&tentry.key), &user_schedule)))
706 es_Report("In KAChangePassword: key_sched returned %d\n", code);
707 DES_pcbc_encrypt(arequest->SeqBody, &request,
708 min(arequest->SeqLen, sizeof(request)), &user_schedule,
709 ktc_to_cblockptr(&tentry.key), DECRYPT);
710
711 /* validate the request */
712 request_time = ntohl(request.time); /* reorder date */
713 kvno = ntohl(request.kvno);
714 if (check_ka_skew(request_time, time(NULL), KTC_TIME_UNCERTAINTY) ||
715 strncmp(request.label, KA_CPW_REQ_LABEL, sizeof(request.label)) ||
716 request.spare || kvno > MAXKAKVNO) { /* these are reserved */
717 code = KABADREQUEST;
718 goto abort;
719 }
720
721 /* check to see if the new password was used before, or if there has
722 * not been sufficient time since the last password change
723 */
724 code = impose_reuse_limits(ktc_to_EncryptionKey(&request.newpw), &tentry);
725 if (code) {
726 goto abort;
727 }
728
729 /* Create the Answer Packet */
730 answer_len = sizeof(Date) + KA_LABELSIZE;
731 if (oanswer->MaxSeqLen < answer_len) {
732 code = KAANSWERTOOLONG;
733 goto abort;
734 }
735 oanswer->SeqLen = answer_len;
736 answer = oanswer->SeqBody;
737 request.time = htonl(request_time + 1);
738 memcpy(answer, (char *)&request.time, sizeof(Date));
739 answer += sizeof(Date);
740 memcpy(answer, KA_CPW_ANS_LABEL, KA_LABELSIZE);
741
742 DES_pcbc_encrypt(oanswer->SeqBody, oanswer->SeqBody, answer_len,
743 &user_schedule, ktc_to_cblockptr(&tentry.key), ENCRYPT);
744
745 code = set_password(tt, aname, ainstance, &request.newpw, kvno, 0);
746 if (code) {
747 code = KAIO;
748 goto abort;
749 }
750
751 cheader.stats.cpws = htonl(ntohl(cheader.stats.cpws) + 1);
752 code =
753 kawrite(tt, DOFFSET(0, &cheader, &cheader.stats.cpws),
754 (char *)&cheader.stats.cpws, sizeof(afs_int32));
755 if (code) {
756 code = KAIO;
757 goto abort;
758 }
759
760 code = ubik_EndTrans(tt);
761 return code;
762
763 abort:
764 COUNT_ABO;
765 ubik_AbortTrans(tt);
766 return code;
767 }
768
769 static afs_int32
770 impose_reuse_limits(EncryptionKey *password, struct kaentry *tentry)
771 {
772 int code;
773 Date now;
774 int i;
775 extern int MinHours;
776 afs_uint32 newsum;
777
778 if (!tentry->pwsums[0] && npwSums > 1 && !tentry->pwsums[1])
779 return 0; /* password reuse limits not in effect */
780
781 code = get_time(&now, 0, 0);
782 if (code)
783 return code;
784
785 if ((now - ntohl(tentry->change_password_time)) < MinHours * 60 * 60)
786 return KATOOSOON;
787
788 if (!memcmp(password, &(tentry->key), sizeof(EncryptionKey)))
789 return KAREUSED;
790
791 code = ka_KeyCheckSum((char *)password, &newsum);
792 if (code)
793 return code;
794
795 newsum = newsum & 0x000000ff;
796 for (i = 0; i < npwSums; i++) {
797 if (newsum == tentry->pwsums[i])
798 return KAREUSED;
799 }
800
801 return 0;
802 }
803
804
805 static afs_int32
806 set_password(struct ubik_trans *tt, char *name, char *instance,
807 struct ktc_encryptionKey *password, afs_int32 kvno, afs_int32 caller)
808 {
809 afs_int32 code;
810 afs_int32 to; /* offset of block */
811 struct kaentry tentry;
812 Date now;
813 int i;
814 extern int npwSums;
815 afs_uint32 newsum;
816
817 code = FindBlock(tt, name, instance, &to, &tentry);
818 if (code)
819 return code;
820 if (to == 0)
821 return KANOENT; /* no such user */
822
823 /* if password reuse limits in effect, set the checksums, the hard way */
824 if (!tentry.pwsums[0] && npwSums > 1 && !tentry.pwsums[1]) {
825 /* do nothing, no limits */ ;
826 } else {
827 code = ka_KeyCheckSum((char *)&(tentry.key), &newsum);
828 if (code)
829 return code;
830 for (i = npwSums - 1; i; i--)
831 tentry.pwsums[i] = tentry.pwsums[i - 1];
832 tentry.pwsums[0] = newsum & 0x000000ff;
833 }
834
835
836 if (special_name(name, instance)) { /* set key over rides key_version */
837 tentry.flags = htonl(ntohl(tentry.flags) | KAFSPECIAL);
838 if ((code = ka_NewKey(tt, to, &tentry, password)))
839 return (code);
840 } else {
841 memcpy(&tentry.key, password, sizeof(tentry.key));
842 if (!kvno) {
843 kvno = ntohl(tentry.key_version);
844 if ((kvno < 1) || (kvno >= MAXKAKVNO))
845 kvno = 1;
846 else
847 kvno++;
848 }
849 tentry.key_version = htonl((afs_int32) kvno); /* requested key version */
850 }
851
852
853
854 /* no-write prevents recursive call to set_password by AuthCPW code. */
855 code = get_time(&now, 0, 0);
856 if (code)
857 return code;
858 if (caller) {
859 tentry.modification_time = htonl(now);
860 tentry.modification_id = htonl(caller);
861 }
862
863 tentry.change_password_time = htonl(now);
864
865 if ((code = kawrite(tt, to, (char *) &tentry, sizeof(tentry))))
866 return (KAIO);
867 return (0);
868 }
869
870 afs_int32
871 SKAM_SetPassword(struct rx_call *call, char *aname, char *ainstance,
872 afs_int32 akvno, EncryptionKey apassword)
873 {
874 afs_int32 code;
875
876 code = kamSetPassword(call, aname, ainstance, akvno, apassword);
877 osi_auditU(call, AFS_KAM_SetPswdEvent, code, AUD_STR, aname, AUD_STR,
878 ainstance, AUD_END);
879 return code;
880 }
881
882 afs_int32
883 kamSetPassword(struct rx_call *call, char *aname, char *ainstance,
884 afs_int32 akvno, EncryptionKey apassword)
885 {
886 int code;
887 struct ubik_trans *tt;
888 afs_int32 caller; /* Disk offset of caller's entry */
889 struct kaentry tentry;
890
891 COUNT_REQ(SetPassword);
892 if (akvno > MAXKAKVNO)
893 return KABADARGUMENT;
894 if (!DES_check_key_parity(EncryptionKey_to_cblock(&apassword)) ||
895 DES_is_weak_key(EncryptionKey_to_cblock(&apassword)))
896 return KABADKEY;
897
898 if (!name_instance_legal(aname, ainstance))
899 return KABADNAME;
900 if ((code = InitAuthServ(&tt, LOCKWRITE, this_op)))
901 return code;
902 code = check_auth(call, tt, 0, &caller);
903 if (code) {
904 goto abort;
905 }
906 if ((code = karead(tt, caller, (char *)&tentry, sizeof(tentry)))) {
907 code = KAIO;
908 goto abort;
909 }
910 /* if the user is changing his own password or ADMIN then go ahead. */
911 if ((strcmp(tentry.userID.name, aname) == 0)
912 && (strcmp(tentry.userID.instance, ainstance) == 0)) {
913 if (ntohl(tentry.flags) & KAFNOCPW)
914 code = KABADCPW;
915 else {
916 code = impose_reuse_limits(&apassword, &tentry);
917 if (!code)
918 code =
919 set_password(tt, aname, ainstance, EncryptionKey_to_ktc(&apassword), akvno, 0);
920 }
921 } else if (ntohl(tentry.flags) & KAFADMIN) {
922 code = set_password(tt, aname, ainstance, EncryptionKey_to_ktc(&apassword), akvno, caller);
923 } else
924 code = KANOAUTH;
925 if (code)
926 goto abort;
927
928 code = ubik_EndTrans(tt);
929 KALOG(aname, ainstance, NULL, NULL, NULL,
930 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_CHPASSWD);
931 return code;
932
933 abort:
934 COUNT_ABO;
935 ubik_AbortTrans(tt);
936 return code;
937 }
938
939 static Date
940 CoerseLifetime(Date start, Date end)
941 {
942 unsigned char kerberosV4Life;
943 kerberosV4Life = time_to_life(start, end);
944 end = life_to_time(start, kerberosV4Life);
945 return end;
946 }
947
948 static afs_int32
949 GetEndTime(Date start, /* start time of ticket */
950 Date reqEnd, /* requested end time */
951 Date expiration, /* authorizing ticket's expiration */
952 struct kaentry *caller,
953 struct kaentry *server,
954 Date *endP) /* actual end time */
955 {
956 Date cExp, sExp;
957 Date cLife, sLife;
958 Date end;
959
960 if (ntohl(caller->flags) & KAFNOTGS)
961 return KABADUSER; /* no new tickets for this user */
962 if (expiration && (ntohl(server->flags) & KAFNOSEAL))
963 return KABADSERVER; /* can't be target of GetTicket req */
964 if (!expiration)
965 expiration = NEVERDATE;
966
967 cExp = ntohl(caller->user_expiration);
968 sExp = ntohl(server->user_expiration);
969 if (cExp < start)
970 return KAPWEXPIRED;
971 if (sExp < start)
972 return KABADSERVER;
973 cLife = start + ntohl(caller->max_ticket_lifetime);
974 sLife = start + ntohl(server->max_ticket_lifetime);
975 end =
976 umin(umin(reqEnd, expiration),
977 umin(umin(cLife, sLife), umin(cExp, sExp)));
978 end = CoerseLifetime(start, end);
979 *endP = end;
980 return 0;
981 }
982
983 static afs_int32
984 PrepareTicketAnswer(ka_BBS *oanswer, afs_int32 challenge, char *ticket,
985 afs_int32 ticketLen, struct ktc_encryptionKey *sessionKey,
986 Date start, Date end, struct kaentry *caller,
987 struct kaentry *server, char *cell, char *label)
988 {
989 afs_int32 code;
990 struct ka_ticketAnswer *answer;
991 afs_int32 cksum;
992
993 code = KAANSWERTOOLONG;
994 if (oanswer->MaxSeqLen <
995 sizeof(struct ka_ticketAnswer) - 5 * MAXKTCNAMELEN - MAXKTCTICKETLEN +
996 ticketLen)
997 return code;
998
999 answer = (struct ka_ticketAnswer *)oanswer->SeqBody;
1000 answer->challenge = htonl(challenge);
1001 memcpy(&answer->sessionKey, sessionKey, sizeof(struct ktc_encryptionKey));
1002 answer->startTime = htonl(start);
1003 answer->endTime = htonl(end);
1004 answer->kvno = server->key_version;
1005 answer->ticketLen = htonl(ticketLen);
1006
1007 {
1008 char *ans = answer->name; /* pointer to variable part */
1009 int rem; /* space remaining */
1010 int len; /* macro temp. */
1011
1012 rem = oanswer->MaxSeqLen - (ans - oanswer->SeqBody);
1013 #undef putstr
1014 #define putstr(str) len = strlen (str)+1;\
1015 if (rem < len) return code;\
1016 strcpy (ans, str);\
1017 ans += len; rem -= len
1018 putstr(caller->userID.name);
1019 putstr(caller->userID.instance);
1020 putstr(cell);
1021 putstr(server->userID.name);
1022 putstr(server->userID.instance);
1023 if (rem < ticketLen + KA_LABELSIZE)
1024 return code;
1025 memcpy(ans, ticket, ticketLen);
1026 ans += ticketLen;
1027 if (label)
1028 memcpy(ans, label, KA_LABELSIZE);
1029 else
1030 memset(ans, 0, KA_LABELSIZE);
1031 ans += KA_LABELSIZE;
1032 oanswer->SeqLen = (ans - oanswer->SeqBody);
1033 }
1034 cksum = 0;
1035 answer->cksum = htonl(cksum);
1036 oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
1037 if (oanswer->SeqLen > oanswer->MaxSeqLen)
1038 return code;
1039 return 0;
1040 }
1041
1042 /* This is used to get a ticket granting ticket or an admininstration ticket.
1043 These two specific, built-in servers are special cases, which require the
1044 client's key as an additional security precaution. The GetTicket operation
1045 is normally disabled for these two principals. */
1046
1047 static afs_int32
1048 Authenticate(int version, struct rx_call *call, char *aname, char *ainstance,
1049 Date start, Date end, ka_CBS *arequest, ka_BBS *oanswer)
1050 {
1051 int code;
1052 struct ubik_trans *tt;
1053 afs_int32 to; /* offset of block */
1054 kaentry tentry;
1055 struct kaentry server; /* entry for desired server */
1056 struct ka_gettgtRequest request; /* request after decryption */
1057 int tgt, adm; /* type of request */
1058 char *sname; /* principal of server */
1059 char *sinst;
1060 char ticket[MAXKTCTICKETLEN]; /* our copy of the ticket */
1061 int ticketLen;
1062 struct ktc_encryptionKey sessionKey; /* we have to invent a session key */
1063 char *answer; /* where answer is to be put */
1064 int answer_len; /* length of answer packet */
1065 Date answer_time; /* 1+ request time in network order */
1066 afs_int32 temp; /* for htonl conversions */
1067 DES_key_schedule user_schedule; /* key schedule for user's key */
1068 afs_int32 tgskvno; /* key version of service key */
1069 struct ktc_encryptionKey tgskey; /* service key for encrypting ticket */
1070 Date now;
1071 afs_uint32 pwexpires;
1072
1073 COUNT_REQ(Authenticate);
1074 if (!name_instance_legal(aname, ainstance))
1075 return KABADNAME;
1076 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
1077 return code;
1078 get_time(&now, 0, 0);
1079
1080 sname = sinst = NULL;
1081
1082 code = FindBlock(tt, aname, ainstance, &to, &tentry);
1083 if (code) {
1084 goto abort;
1085 }
1086 if (to == 0) { /* no such user */
1087 code = KANOENT;
1088 goto abort;
1089 }
1090 #ifdef LOCKPW
1091 /* have to check for locked before verifying the password, otherwise all
1092 * KALOCKED means is "yup, you guessed the password all right, now wait a
1093 * few minutes and we'll let you in"
1094 */
1095 if (kaux_islocked
1096 (to, (u_int) tentry.misc_auth_bytes[ATTEMPTS],
1097 (afs_uint32) tentry.misc_auth_bytes[LOCKTIME] << 9)) {
1098 code = KALOCKED;
1099 goto abort;
1100 }
1101 #endif /* LOCKPW */
1102
1103 save_principal(authPrincipal, aname, ainstance, 0);
1104
1105 /* decrypt request w/ user password */
1106 if ((code = DES_key_sched(ktc_to_cblock(&tentry.key), &user_schedule)))
1107 es_Report("In KAAuthenticate: key_sched returned %d\n", code);
1108 DES_pcbc_encrypt(arequest->SeqBody, &request,
1109 min(arequest->SeqLen, sizeof(request)), &user_schedule,
1110 ktc_to_cblockptr(&tentry.key), DECRYPT);
1111
1112 request.time = ntohl(request.time); /* reorder date */
1113 tgt = !strncmp(request.label, KA_GETTGT_REQ_LABEL, sizeof(request.label));
1114 adm = !strncmp(request.label, KA_GETADM_REQ_LABEL, sizeof(request.label));
1115 if (!(tgt || adm)) {
1116 kaux_inc(to, ((unsigned char)tentry.misc_auth_bytes[LOCKTIME]) << 9);
1117 code = KABADREQUEST;
1118 goto abort;
1119 } else
1120 kaux_write(to, 0, 0); /* reset counters */
1121
1122 #ifdef EXPIREPW
1123 if (!tentry.misc_auth_bytes[EXPIRES]) {
1124 /* 0 in the database means never, but 0 on the network means today */
1125 /* 255 on the network means "long time, maybe never" */
1126 pwexpires = 255;
1127 } else {
1128 pwexpires = tentry.misc_auth_bytes[EXPIRES];
1129
1130 pwexpires =
1131 ntohl(tentry.change_password_time) + 24 * 60 * 60 * pwexpires;
1132 if (adm) { /* provide a little slack for admin ticket */
1133 pwexpires += 30 * 24 * 60 * 60; /* 30 days */
1134 }
1135 if (pwexpires < now) {
1136 code = KAPWEXPIRED;
1137 goto abort;
1138 } else {
1139 pwexpires = (pwexpires - now) / (24 * 60 * 60);
1140 if (pwexpires > 255)
1141 pwexpires = 255;
1142 }
1143 }
1144 #endif /* EXPIREPW */
1145
1146 if (check_ka_skew(request.time, now, KTC_TIME_UNCERTAINTY)) {
1147 #if 0
1148 if (oanswer->MaxSeqLen < sizeof(afs_int32))
1149 code = KAANSWERTOOLONG;
1150 else { /* return our time if possible */
1151 oanswer->SeqLen = sizeof(afs_int32);
1152 request.time = htonl(now);
1153 memcpy(oanswer->SeqBody, &request.time, sizeof(afs_int32));
1154 }
1155 #endif
1156 code = KACLOCKSKEW;
1157 goto abort;
1158 }
1159 sname = (tgt ? KA_TGS_NAME : KA_ADMIN_NAME);
1160 sinst = (tgt ? lrealm : KA_ADMIN_INST);
1161 code = FindBlock(tt, sname, sinst, &to, &server);
1162 if (code)
1163 goto abort;
1164 if (to == 0) {
1165 code = KANOENT;
1166 goto abort;
1167 }
1168
1169 tgskvno = ntohl(server.key_version);
1170 memcpy(&tgskey, &server.key, sizeof(tgskey));
1171
1172 code = DES_new_random_key(ktc_to_cblock(&sessionKey));
1173 if (code) {
1174 code = KANOKEYS;
1175 goto abort;
1176 }
1177
1178 code = GetEndTime(start, end, 0 /*!GetTicket */ , &tentry, &server, &end);
1179 if (code)
1180 goto abort;
1181
1182 code =
1183 tkt_MakeTicket(ticket, &ticketLen, &tgskey, aname, ainstance, "",
1184 start, end, &sessionKey,
1185 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), sname,
1186 sinst);
1187 if (code)
1188 goto abort;
1189
1190 switch (version) {
1191 case 0:
1192 answer_len =
1193 ticketLen + sizeof(Date) + sizeof(struct ktc_encryptionKey) +
1194 2 * sizeof(afs_int32) + KA_LABELSIZE;
1195 answer_len = round_up_to_ebs(answer_len);
1196 if (answer_len > oanswer->MaxSeqLen) {
1197 code = KAANSWERTOOLONG;
1198 goto abort;
1199 }
1200 oanswer->SeqLen = answer_len;
1201 answer = oanswer->SeqBody;
1202 answer_time = htonl(request.time + 1);
1203 memcpy(answer, (char *)&answer_time, sizeof(Date));
1204 answer += sizeof(Date);
1205 memcpy(answer, (char *)&sessionKey, sizeof(struct ktc_encryptionKey));
1206 answer += sizeof(struct ktc_encryptionKey);
1207 temp = htonl(tgskvno);
1208 memcpy(answer, (char *)&temp, sizeof(afs_int32));
1209 answer += sizeof(afs_int32);
1210 temp = htonl(ticketLen);
1211 memcpy(answer, (char *)&temp, sizeof(afs_int32));
1212 answer += sizeof(afs_int32);
1213 memcpy(answer, ticket, ticketLen);
1214 answer += ticketLen;
1215 memcpy(answer, (tgt ? KA_GETTGT_ANS_LABEL : KA_GETADM_ANS_LABEL),
1216 KA_LABELSIZE);
1217 break;
1218 case 1:
1219 case 2:
1220 code =
1221 PrepareTicketAnswer(oanswer, request.time + 1, ticket, ticketLen,
1222 &sessionKey, start, end, &tentry, &server, "",
1223 (tgt ? KA_GETTGT_ANS_LABEL :
1224 KA_GETADM_ANS_LABEL));
1225 if (code)
1226 goto abort;
1227 #ifdef EXPIREPW
1228 if ((version == 2)
1229 && oanswer->SeqLen < oanswer->MaxSeqLen + sizeof(afs_int32)) {
1230 temp = pwexpires << 24; /* move it into the high byte */
1231 pwexpires = htonl(temp);
1232
1233 memcpy((char *)oanswer->SeqBody + oanswer->SeqLen, &pwexpires,
1234 sizeof(afs_int32));
1235 oanswer->SeqLen += sizeof(afs_int32);
1236 oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
1237 if (oanswer->SeqLen > oanswer->MaxSeqLen) {
1238 code = KAANSWERTOOLONG;
1239 goto abort;
1240 }
1241 }
1242 #endif /* EXPIREPW */
1243 break;
1244
1245 default:
1246 code = KAINTERNALERROR;
1247 goto abort;
1248 }
1249 DES_pcbc_encrypt(oanswer->SeqBody, oanswer->SeqBody, oanswer->SeqLen,
1250 &user_schedule, ktc_to_cblockptr(&tentry.key), ENCRYPT);
1251 code = ubik_EndTrans(tt);
1252 KALOG(aname, ainstance, sname, sinst, NULL,
1253 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_AUTHENTICATE);
1254 return code;
1255
1256 abort:
1257 COUNT_ABO;
1258 ubik_AbortTrans(tt);
1259 KALOG(aname, ainstance, sname, sinst, NULL,
1260 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_AUTHFAILED);
1261 return code;
1262 }
1263
1264 afs_int32
1265 SKAA_Authenticate_old(struct rx_call *call, char *aname, char *ainstance,
1266 Date start, Date end, ka_CBS *arequest,
1267 ka_BBS *oanswer)
1268 {
1269 int code;
1270
1271 IOMGR_Sleep(1); /* discourage use of this mechanism */
1272 code =
1273 Authenticate(0, call, aname, ainstance, start, end, arequest,
1274 oanswer);
1275 osi_auditU(call, AFS_KAA_AuthOEvent, code, AUD_STR, aname, AUD_STR,
1276 ainstance, AUD_END);
1277
1278 return code;
1279 }
1280
1281 afs_int32
1282 SKAA_Authenticate(struct rx_call *call, char *aname, char *ainstance,
1283 Date start, Date end, ka_CBS *arequest, ka_BBS *oanswer)
1284 {
1285 int code;
1286
1287 code =
1288 Authenticate(1, call, aname, ainstance, start, end, arequest,
1289 oanswer);
1290 osi_auditU(call, AFS_KAA_AuthEvent, code, AUD_STR, aname, AUD_STR,
1291 ainstance, AUD_END);
1292
1293 return code;
1294 }
1295
1296 afs_int32
1297 SKAA_AuthenticateV2(struct rx_call *call, char *aname, char *ainstance,
1298 Date start, Date end, ka_CBS *arequest, ka_BBS *oanswer)
1299 {
1300 int code;
1301
1302 code =
1303 Authenticate(2, call, aname, ainstance, start, end, arequest,
1304 oanswer);
1305 osi_auditU(call, AFS_KAA_AuthEvent, code, AUD_STR, aname, AUD_STR,
1306 ainstance, AUD_END);
1307
1308 return code;
1309 }
1310
1311 afs_int32
1312 SKAM_SetFields(struct rx_call *call,
1313 char *aname,
1314 char *ainstance,
1315 afs_int32 aflags,
1316 Date aexpiration,
1317 afs_int32 alifetime,
1318 afs_int32 amaxAssociates,
1319 afs_uint32 misc_auth_bytes, /* 4 bytes, each 0 means unspecified */
1320 afs_int32 spare2)
1321 {
1322 afs_int32 code;
1323
1324 code =
1325 kamSetFields(call, aname, ainstance, aflags, aexpiration, alifetime,
1326 amaxAssociates, misc_auth_bytes, spare2);
1327 osi_auditU(call, AFS_KAM_SetFldEvent, code, AUD_STR, aname, AUD_STR,
1328 ainstance, AUD_LONG, aflags, AUD_DATE, aexpiration, AUD_LONG,
1329 alifetime, AUD_LONG, amaxAssociates, AUD_END);
1330 return code;
1331 }
1332
1333 afs_int32
1334 kamSetFields(struct rx_call *call,
1335 char *aname,
1336 char *ainstance,
1337 afs_int32 aflags,
1338 Date aexpiration,
1339 afs_int32 alifetime,
1340 afs_int32 amaxAssociates,
1341 afs_uint32 misc_auth_bytes, /* 4 bytes, each 0 means unspecified */
1342 afs_int32 spare2)
1343 {
1344 afs_int32 code;
1345 Date now;
1346 struct ubik_trans *tt;
1347 afs_int32 caller;
1348 afs_int32 tentry_offset; /* offset of entry */
1349 struct kaentry tentry;
1350 unsigned char newvals[4];
1351
1352 COUNT_REQ(SetFields);
1353
1354 if (spare2)
1355 return KABADARGUMENT; /* not supported yet... */
1356
1357 /* make sure we're supposed to do something */
1358 if (!(aflags || aexpiration || alifetime || (amaxAssociates >= 0)
1359 || misc_auth_bytes)
1360 || ((aflags & ~KAFNORMAL) & ~KAF_SETTABLE_FLAGS))
1361 return KABADARGUMENT; /* arguments no good */
1362 if (!name_instance_legal(aname, ainstance))
1363 return KABADNAME;
1364 if ((code = InitAuthServ(&tt, LOCKWRITE, this_op)))
1365 return code;
1366 code = check_auth(call, tt, 1, &caller);
1367 if (code) {
1368 goto abort;
1369 }
1370
1371 code = FindBlock(tt, aname, ainstance, &tentry_offset, &tentry);
1372 if (code)
1373 goto abort;
1374 if (tentry_offset == 0) { /* no such user */
1375 code = KANOENT;
1376 goto abort;
1377 }
1378 if ((ntohl(tentry.flags) & KAFNORMAL) == 0)
1379 return KAINTERNALERROR;
1380 if (aflags) {
1381 /* Keep track of the total number of admin accounts. This way we can
1382 * update database without any admin privilege initially */
1383 if ((aflags & KAFADMIN) != (ntohl(tentry.flags) & KAFADMIN)) {
1384 /* if admin state is changing */
1385 int delta;
1386 if (ntohl(tentry.flags) & KAFADMIN)
1387 delta = -1;
1388 else
1389 delta = 1;
1390 if ((code = update_admin_count(tt, delta)))
1391 goto abort;
1392 }
1393 tentry.flags =
1394 htonl((ntohl(tentry.flags) & ~KAF_SETTABLE_FLAGS) | aflags);
1395 }
1396 if ((code = get_time(&now, tt, 1)))
1397 goto abort;
1398 if (aexpiration) {
1399 tentry.user_expiration = htonl(aexpiration);
1400 if (!ntohl(tentry.change_password_time)) {
1401 tentry.change_password_time = htonl(now);
1402 }
1403 }
1404 if (alifetime)
1405 tentry.max_ticket_lifetime = htonl(alifetime);
1406
1407 #ifndef NOPWCONTROLS
1408 /*
1409 * We've packed a bunch of bytes into a long for backward compatibility.
1410 * These include password expiration time, and some failed login limits
1411 * counters. Now let's unpack them and stick them into the
1412 * kaentry struct. All the bytes have values in the range
1413 * 1..255, else they were not specified in the interface, and are
1414 * set to zero.
1415 * In the case of password expiration times, 1 means password never
1416 * expires (==>0), 2 means password only lives for one day (==>1),
1417 * and so on.
1418 */
1419 if (misc_auth_bytes) {
1420 unpack_long(misc_auth_bytes, newvals);
1421 if (newvals[EXPIRES]) {
1422 tentry.misc_auth_bytes[EXPIRES] = newvals[EXPIRES] - 1;
1423 }
1424
1425 if (newvals[REUSEFLAGS]) {
1426 if (newvals[REUSEFLAGS] & KA_REUSEPW)
1427 memset(tentry.pwsums, 0, KA_NPWSUMS);
1428 else if ((newvals[REUSEFLAGS] & KA_NOREUSEPW)
1429 && !tentry.pwsums[0])
1430 tentry.pwsums[0] = 0xff;
1431 }
1432
1433 if (newvals[ATTEMPTS]) {
1434 tentry.misc_auth_bytes[ATTEMPTS] = newvals[ATTEMPTS] - 1;
1435 }
1436 if (newvals[LOCKTIME]) {
1437 tentry.misc_auth_bytes[LOCKTIME] = newvals[LOCKTIME] - 1;
1438 }
1439 /*
1440 tentry.misc_auth_bytes = htonl(tentry.misc_auth_bytes);
1441 */
1442 }
1443 #endif /* NOPWCONTROLS */
1444
1445 if (amaxAssociates >= 0) {
1446 if ((ntohl(tentry.flags) & KAFASSOC)
1447 || (ntohl(tentry.flags) & KAFSPECIAL))
1448 return KAASSOCUSER;
1449 if (((ntohl(tentry.flags) & KAFASSOCROOT) == 0) && (amaxAssociates > 0)) /* convert normal user to assoc root */
1450 tentry.flags = htonl(ntohl(tentry.flags) | KAFASSOCROOT);
1451 tentry.misc.assocRoot.maxAssociates = htonl(amaxAssociates);
1452 }
1453
1454 tentry.modification_time = htonl(now);
1455 tentry.modification_id = htonl(caller);
1456 code = kawrite(tt, tentry_offset, (char *) &tentry, sizeof(tentry));
1457 if (code)
1458 goto abort;
1459
1460 code = ubik_EndTrans(tt);
1461 KALOG(aname, ainstance, NULL, NULL, NULL,
1462 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_SETFIELDS);
1463 return code;
1464
1465 abort:
1466 COUNT_ABO;
1467 ubik_AbortTrans(tt);
1468 return code;
1469 }
1470
1471 /* delete a user */
1472
1473 afs_int32
1474 SKAM_DeleteUser(struct rx_call *call, char *aname, char *ainstance)
1475 {
1476 afs_int32 code;
1477
1478 code = kamDeleteUser(call, aname, ainstance);
1479 osi_auditU(call, AFS_KAM_DelUserEvent, code, AUD_STR, aname, AUD_STR,
1480 ainstance, AUD_END);
1481 return code;
1482 }
1483
1484 afs_int32
1485 kamDeleteUser(struct rx_call *call, char *aname, char *ainstance)
1486 {
1487 int code;
1488 struct ubik_trans *tt;
1489 afs_int32 caller;
1490 afs_int32 to;
1491 struct kaentry tentry;
1492 unsigned int nfailures;
1493 afs_uint32 locktime;
1494
1495 COUNT_REQ(DeleteUser);
1496 if (!name_instance_legal(aname, ainstance))
1497 return KABADNAME;
1498 if ((code = InitAuthServ(&tt, LOCKWRITE, this_op)))
1499 return code;
1500 code = check_auth(call, tt, 1, &caller);
1501 if (code) {
1502 abort:
1503 COUNT_ABO;
1504 ubik_AbortTrans(tt);
1505 return code;
1506 }
1507
1508 code = FindBlock(tt, aname, ainstance, &to, &tentry);
1509 if (code)
1510 goto abort;
1511 if (to == 0) { /* name not found */
1512 code = KANOENT;
1513 goto abort;
1514 }
1515
1516 kaux_read(to, &nfailures, &locktime);
1517 if (nfailures || locktime)
1518 kaux_write(to, 0, 0); /* zero failure counters at this offset */
1519
1520 /* track all AuthServer identities */
1521 if (special_name(aname, ainstance))
1522 if ((code = ka_DelKey(tt, to, &tentry)))
1523 goto abort;
1524
1525 if (ntohl(tentry.flags) & KAFADMIN) /* keep admin count up-to-date */
1526 if ((code = update_admin_count(tt, -1)))
1527 goto abort;
1528
1529 if ((code = UnthreadBlock(tt, &tentry)) || (code = FreeBlock(tt, to)) || (code = get_time(0, tt, 1)) /* update randomness */
1530 )
1531 goto abort;
1532
1533 code = ubik_EndTrans(tt);
1534 KALOG(aname, ainstance, NULL, NULL, NULL,
1535 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_DELUSER);
1536 return code;
1537 }
1538
1539 /* we set a bit in here which indicates that the user's limit of
1540 * authentication failures has been exceeded. If that bit is not set,
1541 * kas can take it on faith that the user ID is not locked. If that
1542 * bit is set, kas has to check all the servers to find one who will
1543 * report that the ID is not locked, or else to find out when the ID
1544 * will be unlocked.
1545 */
1546 afs_int32
1547 SKAM_GetEntry(struct rx_call *call,
1548 char *aname,
1549 char *ainstance,
1550 afs_int32 aversion, /* major version assumed by caller */
1551 kaentryinfo *aentry) /* entry data copied here */
1552 {
1553 afs_int32 code;
1554
1555 code = kamGetEntry(call, aname, ainstance, aversion, aentry);
1556 osi_auditU(call, AFS_KAM_GetEntEvent, code, AUD_STR, aname, AUD_STR,
1557 ainstance, AUD_END);
1558 return code;
1559 }
1560
1561 afs_int32
1562 kamGetEntry(struct rx_call *call,
1563 char *aname,
1564 char *ainstance,
1565 afs_int32 aversion, /* major version assumed by caller */
1566 kaentryinfo *aentry) /* entry data copied here */
1567 {
1568 afs_int32 code;
1569 struct ubik_trans *tt;
1570 afs_int32 callerIndex;
1571 struct kaentry caller;
1572 afs_int32 to;
1573 afs_uint32 temp;
1574 struct kaentry tentry;
1575 rxkad_level enc_level = rxkad_clear;
1576 int callerIsAdmin = 0;
1577
1578 COUNT_REQ(GetEntry);
1579 if (aversion != KAMAJORVERSION)
1580 return KAOLDINTERFACE;
1581 if (!name_instance_legal(aname, ainstance))
1582 return KABADNAME;
1583 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
1584 return code;
1585 code = check_auth(call, tt, 0, &callerIndex);
1586 if (code) {
1587 goto abort;
1588 }
1589 if (noAuthenticationRequired) {
1590 } else if (!callerIndex) {
1591 code = KANOENT;
1592 goto abort;
1593 } else {
1594 if ((code = karead(tt, callerIndex, (char *)&caller, sizeof(caller)))) {
1595 code = KAIO;
1596 goto abort;
1597 }
1598 /* if the user is checking his own entry or ADMIN then go ahead. */
1599 callerIsAdmin = (ntohl(caller.flags) & KAFADMIN);
1600
1601 if (strcmp(caller.userID.name, aname) != 0 && !callerIsAdmin) {
1602 code = KANOAUTH;
1603 goto abort;
1604 }
1605 }
1606
1607 code = FindBlock(tt, aname, ainstance, &to, &tentry);
1608 if (code)
1609 goto abort;
1610 if (to == 0) { /* entry not found */
1611 code = KANOENT;
1612 goto abort;
1613 }
1614
1615 get_time(0, 0, 0); /* generate random update */
1616
1617 memset(aentry, 0, sizeof(*aentry));
1618 aentry->minor_version = KAMINORVERSION;
1619 aentry->flags = ntohl(tentry.flags);
1620 aentry->user_expiration = ntohl(tentry.user_expiration);
1621 aentry->modification_time = ntohl(tentry.modification_time);
1622 aentry->change_password_time = ntohl(tentry.change_password_time);
1623 aentry->max_ticket_lifetime = ntohl(tentry.max_ticket_lifetime);
1624 aentry->key_version = ntohl(tentry.key_version);
1625
1626 temp = (unsigned char)tentry.misc_auth_bytes[LOCKTIME];
1627 temp = temp << 9;
1628 if (kaux_islocked(to, (u_int) tentry.misc_auth_bytes[ATTEMPTS], temp))
1629 tentry.misc_auth_bytes[REUSEFLAGS] |= KA_ISLOCKED; /* saves an RPC */
1630
1631 temp = pack_long(tentry.misc_auth_bytes);
1632 aentry->misc_auth_bytes = temp;
1633 /*
1634 * only return user's key if security disabled or if admin and
1635 * we have an encrypted connection to the user
1636 */
1637 rxkad_GetServerInfo(rx_ConnectionOf(call), &enc_level, 0, 0, 0, 0, 0);
1638 if ((noAuthenticationRequired)
1639 || (callerIsAdmin && enc_level == rxkad_crypt))
1640 memcpy(&aentry->key, &tentry.key, sizeof(struct ktc_encryptionKey));
1641 else
1642 memset(&aentry->key, 0, sizeof(aentry->key));
1643
1644 code = ka_KeyCheckSum((char *)&tentry.key, &aentry->keyCheckSum);
1645 if (code)
1646 goto abort;
1647
1648 if (!tentry.pwsums[0] && npwSums > 1 && !tentry.pwsums[1]) {
1649 aentry->reserved3 = 0x12340000;
1650 } else {
1651 aentry->reserved3 = 0x12340001;
1652 }
1653
1654 /* Now get entry of user who last modified this entry */
1655 if (ntohl(tentry.modification_id)) {
1656 temp = ntohl(tentry.modification_id);
1657 code = karead(tt, temp, (char *)&tentry, sizeof(tentry));
1658 if (code) {
1659 code = KAIO;
1660 goto abort;
1661 }
1662 aentry->modification_user = tentry.userID;
1663 } else {
1664 strcpy(aentry->modification_user.name, "<none>");
1665 strcpy(aentry->modification_user.instance, "\0");
1666 }
1667 code = ubik_EndTrans(tt);
1668 return code;
1669
1670 abort:
1671 COUNT_ABO;
1672 ubik_AbortTrans(tt);
1673 return code;
1674 }
1675
1676 afs_int32
1677 SKAM_ListEntry(struct rx_call *call,
1678 afs_int32 previous_index, /* last entry ret'd or 0 for first */
1679 afs_int32 *index, /* index of this entry */
1680 afs_int32 *count, /* total entries in database */
1681 kaident *name) /* name & instance of this entry */
1682 {
1683 afs_int32 code;
1684
1685 code = kamListEntry(call, previous_index, index, count, name);
1686 osi_auditU(call, AFS_KAM_LstEntEvent, code, AUD_LONG, *index, AUD_END);
1687 return code;
1688 }
1689
1690
1691 afs_int32
1692 kamListEntry(struct rx_call *call,
1693 afs_int32 previous_index, /* last entry ret'd or 0 for first */
1694 afs_int32 *index, /* index of this entry */
1695 afs_int32 *count, /* total entries in database */
1696 kaident *name) /* name & instance of this entry */
1697 {
1698 int code;
1699 struct ubik_trans *tt;
1700 afs_int32 caller;
1701 struct kaentry tentry;
1702
1703 COUNT_REQ(ListEntry);
1704 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
1705 return code;
1706 code = check_auth(call, tt, 1, &caller);
1707 if (code) {
1708 goto abort;
1709 }
1710
1711 *index = NextBlock(tt, previous_index, &tentry, count);
1712 if (*count < 0) {
1713 code = KAIO;
1714 goto abort;
1715 }
1716
1717 if (*index) { /* return name & inst of this entry */
1718 strncpy(name->name, tentry.userID.name, sizeof(name->name));
1719 strncpy(name->instance, tentry.userID.instance,
1720 sizeof(name->instance));
1721 } else {
1722 strcpy(name->name, "\0");
1723 strcpy(name->instance, "\0");
1724 }
1725 code = ubik_EndTrans(tt);
1726 return code;
1727
1728 abort:
1729 COUNT_ABO;
1730 ubik_AbortTrans(tt);
1731 return code;
1732 }
1733
1734 static afs_int32
1735 GetTicket(int version,
1736 struct rx_call *call,
1737 afs_int32 kvno,
1738 char *authDomain,
1739 ka_CBS *aticket,
1740 char *sname,
1741 char *sinstance,
1742 ka_CBS *atimes, /* encrypted start & end time */
1743 ka_BBS *oanswer)
1744 {
1745 afs_int32 code;
1746 int import, export;
1747 struct ubik_trans *tt;
1748 struct ktc_encryptionKey tgskey;
1749 DES_key_schedule schedule;
1750 afs_int32 to;
1751 char name[MAXKTCNAMELEN];
1752 char instance[MAXKTCNAMELEN];
1753 char cell[MAXKTCNAMELEN];
1754 int celllen;
1755 struct kaentry caller;
1756 struct kaentry server;
1757 struct ktc_encryptionKey authSessionKey;
1758 struct ktc_encryptionKey sessionKey;
1759 int ticketLen;
1760 char ticket[MAXKTCTICKETLEN];
1761 afs_int32 host;
1762 Date start;
1763 Date expiration;
1764 Date now;
1765 Date end;
1766 struct ka_getTicketTimes times;
1767 struct ka_getTicketAnswer *answer;
1768
1769 COUNT_REQ(GetTicket);
1770 if (!name_instance_legal(sname, sinstance))
1771 return KABADNAME;
1772 if (atimes->SeqLen != sizeof(times))
1773 return KABADARGUMENT;
1774 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
1775 return code;
1776
1777 export = import = 0;
1778 if ((strcmp(sname, KA_TGS_NAME) == 0) && (strcmp(sinstance, lrealm) != 0))
1779 export = 1;
1780 if ((strlen(authDomain) > 0) && (strcmp(authDomain, lrealm) != 0))
1781 import = 1;
1782
1783 if (strlen(authDomain) == 0)
1784 authDomain = lrealm;
1785 code = ka_LookupKvno(tt, KA_TGS_NAME, authDomain, kvno, &tgskey);
1786 if (code) {
1787 goto abort;
1788 }
1789 code =
1790 tkt_DecodeTicket(aticket->SeqBody, aticket->SeqLen, &tgskey, name,
1791 instance, cell, &authSessionKey, &host, &start,
1792 &expiration);
1793 if (code) {
1794 code = KANOAUTH;
1795 goto abort;
1796 }
1797 save_principal(tgsPrincipal, name, instance, cell);
1798
1799 if ((code = get_time(&now, 0, 0)))
1800 goto abort;
1801
1802 code = tkt_CheckTimes(start, expiration, now);
1803 if (code <= 0) {
1804 if (code == -1)
1805 code = RXKADEXPIRED;
1806 else
1807 code = KANOAUTH;
1808 goto abort;
1809 }
1810 code = DES_key_sched(ktc_to_cblock(&authSessionKey), &schedule);
1811 if (code) {
1812 code = KANOAUTH;
1813 goto abort;
1814 }
1815 celllen = strlen(cell);
1816 if (import && (celllen == 0)) {
1817 code = KABADTICKET;
1818 goto abort;
1819 }
1820 if (export && (celllen == 0))
1821 strcpy(cell, lrealm);
1822
1823 if (!krb4_cross && celllen && strcmp(lrealm, cell) != 0) {
1824 code = KABADUSER;
1825 goto abort;
1826 }
1827
1828 DES_ecb_encrypt((DES_cblock *)atimes->SeqBody, (DES_cblock *)&times, &schedule, DECRYPT);
1829 times.start = ntohl(times.start);
1830 times.end = ntohl(times.end);
1831 code = tkt_CheckTimes(times.start, times.end, now);
1832 if (code < 0) {
1833 code = KABADREQUEST;
1834 goto abort;
1835 }
1836
1837 if (import) {
1838 strcpy(caller.userID.name, name);
1839 strcpy(caller.userID.instance, instance);
1840 caller.max_ticket_lifetime = htonl(MAXKTCTICKETLIFETIME);
1841 caller.flags = htonl(KAFNORMAL);
1842 caller.user_expiration = htonl(NEVERDATE);
1843 } else {
1844 code = FindBlock(tt, name, instance, &to, &caller);
1845 if (code)
1846 goto abort;
1847 if (to == 0) {
1848 ka_PrintUserID("GetTicket: User ", name, instance, " unknown.\n");
1849 code = KANOENT;
1850 goto abort;
1851 }
1852 }
1853
1854 /* get server's entry */
1855 code = FindBlock(tt, sname, sinstance, &to, &server);
1856 if (code)
1857 goto abort;
1858 if (to == 0) { /* entry not found */
1859 ka_PrintUserID("GetTicket: Server ", sname, sinstance, " unknown.\n");
1860 code = KANOENT;
1861 goto abort;
1862 }
1863 save_principal(tgsServerPrincipal, sname, sinstance, 0);
1864
1865 code = DES_new_random_key(ktc_to_cblock(&sessionKey));
1866 if (code) {
1867 code = KANOKEYS;
1868 goto abort;
1869 }
1870
1871 code =
1872 GetEndTime(times.start, times.end, expiration, &caller, &server,
1873 &end);
1874 if (code)
1875 goto abort;
1876
1877 code =
1878 tkt_MakeTicket(ticket, &ticketLen, &server.key, caller.userID.name,
1879 caller.userID.instance, cell, times.start, end,
1880 &sessionKey,
1881 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))),
1882 server.userID.name, server.userID.instance);
1883 if (code)
1884 goto abort;
1885
1886 switch (version) {
1887 case 0:
1888 code = KAANSWERTOOLONG;
1889 if (oanswer->MaxSeqLen <
1890 sizeof(struct ka_getTicketAnswer) - 5 * MAXKTCNAMELEN -
1891 MAXKTCTICKETLEN + ticketLen)
1892 goto abort;
1893
1894 answer = (struct ka_getTicketAnswer *)oanswer->SeqBody;
1895 memcpy(&answer->sessionKey, &sessionKey,
1896 sizeof(struct ktc_encryptionKey));
1897 answer->startTime = htonl(times.start);
1898 answer->endTime = htonl(end);
1899 answer->kvno = server.key_version;
1900 answer->ticketLen = htonl(ticketLen);
1901
1902 {
1903 char *ans = answer->name; /* ptr to variable part of answer */
1904 int rem, len;
1905
1906 /* space remaining */
1907 rem = oanswer->MaxSeqLen - (ans - oanswer->SeqBody);
1908 #undef putstr
1909 #define putstr(str) len = strlen (str)+1;\
1910 if (rem < len) goto abort;\
1911 strcpy (ans, str);\
1912 ans += len; rem -= len
1913
1914 putstr(name);
1915 putstr(instance);
1916 putstr(cell);
1917 putstr(sname);
1918 putstr(sinstance);
1919 if (rem < ticketLen)
1920 goto abort;
1921 memcpy(ans, ticket, ticketLen);
1922 oanswer->SeqLen = (ans - oanswer->SeqBody) + ticketLen;
1923 }
1924 oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
1925 break;
1926 case 1:
1927 code =
1928 PrepareTicketAnswer(oanswer, /*challenge */ 0, ticket, ticketLen,
1929 &sessionKey, times.start, end, &caller,
1930 &server, cell, KA_GETTICKET_ANS_LABEL);
1931 if (code)
1932 goto abort;
1933 break;
1934 default:
1935 code = KAINTERNALERROR;
1936 goto abort;
1937 }
1938 DES_pcbc_encrypt(oanswer->SeqBody, oanswer->SeqBody, oanswer->SeqLen,
1939 &schedule, ktc_to_cblockptr(&authSessionKey), ENCRYPT);
1940 code = ubik_EndTrans(tt);
1941 KALOG(name, instance, sname, sinstance, (import ? authDomain : NULL),
1942 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_GETTICKET);
1943 return code;
1944
1945 abort:
1946 COUNT_ABO;
1947 ubik_AbortTrans(tt);
1948 return code;
1949 }
1950
1951 afs_int32
1952 SKAT_GetTicket_old(struct rx_call *call,
1953 afs_int32 kvno,
1954 char *authDomain,
1955 ka_CBS *aticket,
1956 char *sname,
1957 char *sinstance,
1958 ka_CBS *atimes, /* encrypted start & end time */
1959 ka_BBS *oanswer)
1960 {
1961 int code;
1962
1963 sleep(1); /* strongly discourage this */
1964 code =
1965 GetTicket(0, call, kvno, authDomain, aticket, sname, sinstance,
1966 atimes, oanswer);
1967
1968 osi_auditU(call, AFS_KAT_GetTicketOEvent, code, AUD_STR, sname, AUD_STR,
1969 sinstance, AUD_END);
1970 return code;
1971 }
1972
1973 afs_int32
1974 SKAT_GetTicket(struct rx_call *call,
1975 afs_int32 kvno,
1976 char *authDomain,
1977 ka_CBS *aticket,
1978 char *sname,
1979 char *sinstance,
1980 ka_CBS *atimes, /* encrypted start & end time */
1981 ka_BBS *oanswer)
1982 {
1983 int code;
1984
1985 code =
1986 GetTicket(1, call, kvno, authDomain, aticket, sname, sinstance,
1987 atimes, oanswer);
1988 osi_auditU(call, AFS_KAT_GetTicketEvent, code, AUD_STR, sname, AUD_STR,
1989 sinstance, AUD_END);
1990 return code;
1991 }
1992
1993 afs_int32
1994 SKAM_GetStats(struct rx_call *call, afs_int32 version,
1995 afs_int32 *admin_accounts, kasstats *statics,
1996 kadstats *dynamics)
1997 {
1998 afs_int32 code;
1999
2000 code = kamGetStats(call, version, admin_accounts, statics, dynamics);
2001 osi_auditU(call, AFS_KAM_GetStatEvent, code, AUD_END);
2002 return code;
2003 }
2004
2005 afs_int32
2006 kamGetStats(struct rx_call *call, afs_int32 version,
2007 afs_int32 *admin_accounts, kasstats *statics,
2008 kadstats *dynamics)
2009 {
2010 afs_int32 code;
2011 struct ubik_trans *tt;
2012 afs_int32 caller;
2013
2014 COUNT_REQ(GetStats);
2015 if (version != KAMAJORVERSION)
2016 return KAOLDINTERFACE;
2017 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
2018 return code;
2019 code = check_auth(call, tt, 1, &caller);
2020 if (code) {
2021 COUNT_ABO;
2022 ubik_AbortTrans(tt);
2023 return code;
2024 }
2025
2026 *admin_accounts = ntohl(cheader.admin_accounts);
2027 /* memcpy((char *)statics, (char *)&cheader.stats, sizeof(kasstats)); */
2028 /* these are stored in network byte order and must be copied */
2029 statics->allocs = ntohl(cheader.stats.allocs);
2030 statics->frees = ntohl(cheader.stats.frees);
2031 statics->cpws = ntohl(cheader.stats.cpws);
2032 #if KADBVERSION != 5
2033 check that the statistics command copies all the fields
2034 #endif
2035 memcpy((char *)dynamics, (char *)&dynamic_statistics, sizeof(kadstats));
2036 statics->minor_version = KAMINORVERSION;
2037 dynamics->minor_version = KAMINORVERSION;
2038
2039 {
2040 int used = 0;
2041 int i;
2042
2043 for (i = 0; i < HASHSIZE; i++)
2044 if (cheader.nameHash[i])
2045 used++;
2046 dynamics->hashTableUtilization =
2047 (used * 10000 + HASHSIZE / 2) / HASHSIZE;
2048 }
2049 {
2050 #if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV)
2051 struct rusage ru;
2052 /* Unfortunately, although aix_22 has a minimal compatibility
2053 * method of getting to some rusage fields (i.e. stime &
2054 * utime), the version that we have doesn't even have the
2055 * related include files needed for the aix vtimes() call; so
2056 * ignore this for aix till v3.1... */
2057 getrusage(RUSAGE_SELF, &ru);
2058 #if (KAMAJORVERSION>5)
2059 memcpy(&dynamics->utime, &ru.ru_utime, sizeof(struct katimeval));
2060 memcpy(&dynamics->stime, &ru.ru_stime, sizeof(struct katimeval));
2061 dynamics->dataSize = ru.ru_idrss;
2062 dynamics->stackSize = ru.ru_isrss;
2063 dynamics->pageFailts = ru.ru_majflt;
2064 #else
2065 dynamics->string_checks =
2066 (afs_int32) (1000.0 *
2067 ((ru.ru_utime.tv_sec +
2068 ru.ru_utime.tv_usec / 1000000.0) +
2069 (ru.ru_stime.tv_sec +
2070 ru.ru_stime.tv_usec / 1000000.0)));
2071 #endif
2072 #endif /* AFS_AIX_ENV && AFS_HPUX_ENV && AFS_NT40_ENV */
2073 }
2074
2075 code = ubik_EndTrans(tt);
2076 return code;
2077 }
2078
2079 afs_int32
2080 SKAM_GetPassword(struct rx_call *call, char *name, EncryptionKey *password)
2081 {
2082 afs_int32 code;
2083
2084 code = kamGetPassword(call, name, password);
2085 osi_auditU(call, AFS_KAM_GetPswdEvent, code, AUD_STR, name, AUD_END);
2086 return code;
2087 }
2088
2089 afs_int32
2090 kamGetPassword(struct rx_call *call, char *name, EncryptionKey *password)
2091 {
2092 int code = KANOAUTH;
2093 AFS_UNUSED COUNT_REQ(GetPassword);
2094 #ifdef GETPASSWORD
2095 {
2096 afs_int32 to;
2097 struct ubik_trans *tt;
2098 struct kaentry tentry;
2099
2100 if (!name_instance_legal(name, ""))
2101 return KABADNAME;
2102 /* only requests from this host work */
2103 if (rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))) !=
2104 htonl(INADDR_LOOPBACK))
2105 return KANOAUTH;
2106 if (code = InitAuthServ(&tt, LOCKREAD, this_op))
2107 return code;
2108
2109 /* this isn't likely to be used because of string to key problems, so since
2110 * this is a temporary thing anyway, we'll use it here. */
2111 {
2112 extern char udpAuthPrincipal[256];
2113
2114 save_principal(udpAuthPrincipal, name, 0, 0);
2115 }
2116
2117 get_time(0, 0, 0); /* update random value */
2118 code = FindBlock(tt, name, "", &to, &tentry);
2119 if (code)
2120 goto abort;
2121 if (to == 0) {
2122 code = KANOENT;
2123 abort:
2124 COUNT_ABO;
2125 ubik_AbortTrans(tt);
2126 return code;
2127 }
2128
2129 memcpy(password, &tentry.key, sizeof(*password));
2130 code = ubik_EndTrans(tt);
2131 }
2132 #endif
2133 return code;
2134 }
2135
2136 afs_int32
2137 SKAM_GetRandomKey(struct rx_call *call, EncryptionKey *key)
2138 {
2139 afs_int32 code;
2140
2141 code = kamGetRandomKey(call, key);
2142 osi_auditU(call, AFS_KAM_GetRndKeyEvent, code, AUD_END);
2143 return code;
2144 }
2145
2146 afs_int32
2147 kamGetRandomKey(struct rx_call *call, EncryptionKey *key)
2148 {
2149 int code;
2150
2151 AFS_UNUSED COUNT_REQ(GetRandomKey);
2152 if ((code = AwaitInitialization()))
2153 return code;
2154 code = DES_new_random_key(EncryptionKey_to_cblock(key));
2155 if (code)
2156 return KANOKEYS;
2157 return 0;
2158 }
2159
2160 afs_int32
2161 SKAM_Debug(struct rx_call *call,
2162 afs_int32 version,
2163 int checkDB, /* start a transaction to examine DB */
2164 struct ka_debugInfo *info)
2165 {
2166 afs_int32 code;
2167
2168 code = kamDebug(call, version, checkDB, info);
2169 osi_auditU(call, AFS_KAM_DbgEvent, code, AUD_END);
2170 return code;
2171 }
2172
2173 afs_int32
2174 kamDebug(struct rx_call *call,
2175 afs_int32 version,
2176 int checkDB, /* start a transaction to examine DB */
2177 struct ka_debugInfo *info)
2178 {
2179 /* COUNT_REQ (Debug); */
2180 if (sizeof(struct kaentry) != sizeof(struct kaOldKeys))
2181 return KAINTERNALERROR;
2182 if (sizeof(struct ka_cpwRequest) % 8)
2183 return KAINTERNALERROR;
2184 if (version != KAMAJORVERSION)
2185 return KAOLDINTERFACE;
2186
2187 memset(info, 0, sizeof(*info));
2188
2189 info->minorVersion = KAMINORVERSION;
2190 info->host = dynamic_statistics.host;
2191 info->startTime = dynamic_statistics.start_time;
2192 info->
2193 #if (KAMAJORVERSION>5)
2194 now
2195 #else
2196 reserved1
2197 #endif
2198 = time(0);
2199 info->noAuth = noAuthenticationRequired;
2200
2201 info->dbVersion = ntohl(cheader.version);
2202 info->dbFreePtr = ntohl(cheader.freePtr);
2203 info->dbEofPtr = ntohl(cheader.eofPtr);
2204 info->dbKvnoPtr = ntohl(cheader.kvnoPtr);
2205 info->dbSpecialKeysVersion = ntohl(cheader.specialKeysVersion);
2206
2207 info->dbHeaderRead = cheaderReadTime;
2208 info->lastTrans = lastTrans;
2209 if (!lastOperation)
2210 lastOperation = "(Not Available)";
2211 strncpy(info->lastOperation, lastOperation, sizeof(info->lastOperation));
2212 strncpy(info->lastAuth, authPrincipal, sizeof(info->lastAuth));
2213 strncpy(info->lastTGS, tgsPrincipal, sizeof(info->lastTGS));
2214 strncpy(info->lastAdmin, adminPrincipal, sizeof(info->lastAdmin));
2215 strncpy(info->lastTGSServer, tgsServerPrincipal,
2216 sizeof(info->lastTGSServer));
2217 {
2218 extern char udpAuthPrincipal[256];
2219 extern char udptgsPrincipal[256];
2220 extern char udptgsServerPrincipal[256];
2221
2222 strncpy(info->lastUAuth, udpAuthPrincipal, sizeof(info->lastUAuth));
2223 strncpy(info->lastUTGS, udptgsPrincipal, sizeof(info->lastUTGS));
2224 strncpy(info->lastUTGSServer, udptgsServerPrincipal,
2225 sizeof(info->lastUTGSServer));
2226 }
2227 info->nextAutoCPW = nextAutoCPWTime;
2228 info->updatesRemaining = autoCPWUpdates - totalUpdates;
2229 ka_debugKeyCache(info);
2230 return 0;
2231 }
2232
2233 /* these are auxiliary routines. They don't do any Ubik stuff. They use
2234 * a tacked-on-the-side data file.
2235 * prob'ly ought to check the noauth flag.
2236 */
2237 #define ABORTIF(A) {if((code = A)){goto abort;}}
2238 afs_int32
2239 SKAM_Unlock(struct rx_call *call,
2240 char *aname,
2241 char *ainstance,
2242 afs_int32 spare1,
2243 afs_int32 spare2,
2244 afs_int32 spare3,
2245 afs_int32 spare4)
2246 {
2247 int code;
2248 struct ubik_trans *tt;
2249 afs_int32 caller;
2250 afs_int32 to;
2251 struct kaentry tentry;
2252
2253 COUNT_REQ(Unlock);
2254 if (!name_instance_legal(aname, ainstance)) {
2255 code = KABADNAME;
2256 goto exit;
2257 }
2258 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
2259 goto exit;
2260
2261 ABORTIF(check_auth(call, tt, 1, &caller));
2262 ABORTIF(FindBlock(tt, aname, ainstance, &to, &tentry));
2263 ABORTIF((to == 0 ? KANOENT : 0));
2264
2265 kaux_write(to, 0, 0); /* zero failure counters at this offset */
2266
2267 code = ubik_EndTrans(tt);
2268 KALOG(aname, ainstance, NULL, NULL, NULL,
2269 rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_UNLOCK);
2270 goto exit;
2271
2272 abort:
2273 COUNT_ABO;
2274 ubik_AbortTrans(tt);
2275
2276 exit:
2277 osi_auditU(call, UnlockEvent, code, AUD_STR, aname, AUD_STR, ainstance,
2278 AUD_END);
2279 return code;
2280 }
2281
2282 afs_int32
2283 SKAM_LockStatus(struct rx_call *call,
2284 char *aname,
2285 char *ainstance,
2286 afs_int32 *lockeduntil,
2287 afs_int32 spare1,
2288 afs_int32 spare2,
2289 afs_int32 spare3,
2290 afs_int32 spare4)
2291 {
2292 int code;
2293 struct ubik_trans *tt;
2294 afs_int32 callerIndex;
2295 afs_int32 to;
2296 struct kaentry caller;
2297 struct kaentry tentry;
2298 afs_uint32 temp;
2299
2300 COUNT_REQ(LockStatus);
2301
2302 if (!name_instance_legal(aname, ainstance)) {
2303 code = KABADNAME;
2304 goto exit;
2305 }
2306 if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
2307 goto exit;
2308
2309 if ((code = check_auth(call, tt, 0, &callerIndex)))
2310 goto abort;
2311
2312 if (!noAuthenticationRequired && callerIndex) {
2313 if (karead(tt, callerIndex, (char *)&caller, sizeof(caller))) {
2314 code = KAIO;
2315 goto abort;
2316 }
2317 /* if the user is checking his own entry or ADMIN then go ahead. */
2318 if ((strcmp(caller.userID.name, aname) != 0)
2319 && !(ntohl(caller.flags) & KAFADMIN)) {
2320 code = KANOAUTH;
2321 goto abort;
2322 }
2323 }
2324
2325 if ((code = FindBlock(tt, aname, ainstance, &to, &tentry)))
2326 goto abort;
2327
2328 if (to == 0) {
2329 code = KANOENT;
2330 goto abort;
2331 }
2332
2333 temp = (unsigned char)tentry.misc_auth_bytes[LOCKTIME];
2334 temp = temp << 9;
2335 *lockeduntil =
2336 kaux_islocked(to, (u_int) tentry.misc_auth_bytes[ATTEMPTS], temp);
2337
2338 code = ubik_EndTrans(tt);
2339 goto exit;
2340
2341 abort:
2342 COUNT_ABO;
2343 ubik_AbortTrans(tt);
2344 osi_auditU(call, LockStatusEvent, code, AUD_STR, aname, AUD_STR,
2345 ainstance, AUD_END);
2346
2347 exit:
2348 return code;
2349 }
Mirror of pkg-k5-afs/openafs.git (OpenAFS Debian packaging)