2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afsconfig.h>
11 #include <afs/param.h>
16 #include <sys/types.h>
24 #include <netinet/in.h>
39 #include <afs/com_err.h>
45 #define UBIK_HEADERSIZE 64
46 #define UBIK_BUFFERSIZE 1024
48 char *whoami = "kadb_check";
54 int listuheader, listkheader, listentries, verbose;
60 struct ubik_hdr uheader;
62 offset = lseek(fd, 0, 0);
64 printf("error: lseek to 0 failed: %d %d\n", offset, errno);
68 /* now read the info */
69 r = read(fd, &uheader, sizeof(uheader));
70 if (r != sizeof(uheader)) {
71 printf("error: read of %d bytes failed: %d %d\n", sizeof(uheader), r,
76 uheader.magic = ntohl(uheader.magic);
77 uheader.size = ntohl(uheader.size);
78 uheader.version.epoch = ntohl(uheader.version.epoch);
79 uheader.version.counter = ntohl(uheader.version.counter);
82 printf("Ubik Header\n");
83 printf(" Magic = 0x%x\n", uheader.magic);
84 printf(" Size = %u\n", uheader.size);
85 printf(" Version.epoch = %u\n", uheader.version.epoch);
86 printf(" Version.counter = %u\n", uheader.version.counter);
89 if (uheader.size != UBIK_HEADERSIZE)
90 printf("Ubik header size is %u (should be %u)\n", uheader.size,
92 if (uheader.magic != UBIK_MAGIC)
93 printf("Ubik header magic is 0x%x (should be 0x%x)\n", uheader.magic,
101 struct kaheader *header;
103 printf("Version = %d\n", header->version);
104 printf("HeaderSize = %d\n", header->headerSize);
105 printf("Free Ptr = %u\n", header->freePtr);
106 printf("EOF Ptr = %u\n", header->eofPtr);
107 printf("Kvno Ptr = %u\n", header->kvnoPtr);
108 printf("SpecialKeysVersion changed = %d\n", header->specialKeysVersion);
109 printf("# admin accounts = %d\n", header->admin_accounts);
110 printf("HashSize = %d\n", header->hashsize);
111 printf("Check Version = %d\n", header->checkVersion);
112 printf("stats.minorVersion = %d\n", header->stats.minor_version);
113 printf("stats.AllocBlock calls = %d\n", header->stats.allocs);
114 printf("stats.FreeBlock calls = %d\n", header->stats.frees);
115 printf("stats.cpw commands = %d\n", header->stats.cpws);
119 PrintEntry(index, entry)
121 struct kaentry *entry;
127 time_t modification_time = entry->modification_time;
128 time_t change_password_time = entry->change_password_time;
129 time_t max_ticket_lifetime = entry->max_ticket_lifetime;
133 i = (index - sizeof(struct kaheader)) / sizeof(struct kaentry);
135 printf("Entry %5d (%u):\n", i, index);
137 if (entry->flags & KAFNORMAL) {
138 printf(" Name = %s", entry->userID.name);
139 if (strlen(entry->userID.instance) > 0) {
140 printf(".%s", entry->userID.instance);
146 if (entry->flags & KAFNORMAL)
148 if (entry->flags & KAFADMIN)
150 if (entry->flags & KAFNOTGS)
152 if (entry->flags & KAFNOSEAL)
154 if (entry->flags & KAFNOCPW)
157 if (entry->flags & KAFNEWASSOC)
159 if (entry->flags & KAFFREE)
161 if (entry->flags & KAFOLDKEYS)
163 if (entry->flags & KAFSPECIAL)
165 if (entry->flags & KAFASSOCROOT)
166 printf("ROOT-ASSOC ");
167 if (entry->flags & KAFASSOC)
171 printf(" Next = %u\n", entry->next);
173 if (entry->flags & KAFFREE)
175 if (entry->flags & KAFOLDKEYS)
178 tt = entry->user_expiration;
179 tm_p = localtime(&tt);
181 strftime(Time, 100, "%m/%d/%Y %H:%M", tm_p);
183 printf(" User Expiration = %s\n",
184 (entry->user_expiration == 0xffffffff) ? "never" : Time);
186 printf(" Password Expiration = %u days %s\n",
187 entry->misc_auth_bytes[EXPIRES],
188 (entry->misc_auth_bytes[EXPIRES] ? "" : "(never)"));
190 printf(" Password Attempts before lock = ");
191 if (!entry->misc_auth_bytes[ATTEMPTS])
192 printf("unlimited\n");
194 printf("%d\n", entry->misc_auth_bytes[ATTEMPTS]);
196 printf(" Password lockout time = ");
197 if (!entry->misc_auth_bytes[LOCKTIME])
198 printf("unlimited\n");
200 printf("%.1f min\n", (entry->misc_auth_bytes[LOCKTIME] * 8.5));
202 printf(" Is entry locked = %s\n",
203 (entry->misc_auth_bytes[REUSEFLAGS] ==
204 KA_ISLOCKED) ? "yes" : "no");
206 printf(" Permit password reuse = %s\n",
207 (!entry->pwsums[0] && !entry->pwsums[1]) ? "yes" : "no");
209 printf(" Mod Time = %u: %s", entry->modification_time,
210 ctime(&modification_time));
211 printf(" Mod ID = %u\n", entry->modification_id);
212 printf(" Change Password Time = %u: %s", entry->change_password_time,
213 ctime(&change_password_time));
214 printf(" Ticket lifetime = %u: %s", entry->max_ticket_lifetime,
215 ctime(&max_ticket_lifetime));
216 printf(" Key Version = %d\n", entry->key_version);
219 ka_PrintBytes((char *)&entry->key, sizeof(entry->key));
222 /* What about asServer structs and such and misc_ath_bytes */
225 /* ntohEntry - convert back to host-order */
226 ntohEntry(struct kaentry *entryp)
228 entryp->flags = ntohl(entryp->flags);
229 entryp->next = ntohl(entryp->next);
230 entryp->user_expiration = ntohl(entryp->user_expiration);
231 entryp->modification_time = ntohl(entryp->modification_time);
232 entryp->modification_id = ntohl(entryp->modification_id);
233 entryp->change_password_time = ntohl(entryp->change_password_time);
234 entryp->max_ticket_lifetime = ntohl(entryp->max_ticket_lifetime);
235 entryp->key_version = ntohl(entryp->key_version);
236 entryp->misc.asServer.nOldKeys = ntohl(entryp->misc.asServer.nOldKeys);
237 entryp->misc.asServer.oldKeys = ntohl(entryp->misc.asServer.oldKeys);
243 struct kaentry *entryp;
245 char name[32], inst[32];
247 ka_ConvertBytes(name, sizeof(name), entryp->userID.name,
248 strlen(entryp->userID.name));
249 ka_ConvertBytes(inst, sizeof(inst), entryp->userID.instance,
250 strlen(entryp->userID.instance));
252 if (strlen(entryp->userID.instance)) {
253 sprintf(principal, "%s.%s", name, inst);
255 strcpy(principal, name);
263 struct kaentry *entryp;
269 /* Special entries are not rebuilt */
270 if (entryp->flags & KAFSPECIAL)
273 fprintf(out, "create -name %s", EntryName(entryp));
275 ka_ConvertBytes(key, sizeof(key), (char *)&entryp->key,
276 sizeof(entryp->key));
277 fprintf(out, " -initial_password foo\n");
280 if (entryp->flags & KAFADMIN)
281 strcat(flags, "+ADMIN");
282 if (entryp->flags & KAFNOTGS)
283 strcat(flags, "+NOTGS");
284 if (entryp->flags & KAFNOSEAL)
285 strcat(flags, "+NOSEAL");
286 if (entryp->flags & KAFNOCPW)
287 strcat(flags, "+NOCPW");
289 fprintf(out, "setfields -name %s", principal);
290 if (strcmp(flags, "") != 0)
291 fprintf(out, " -flags %s", &flags[1]);
292 if (entryp->user_expiration != 0xffffffff) {
293 time_t tt = entryp->user_expiration;
294 strftime(Time, 50, "%m/%d/%Y %H:%M",localtime(&tt));
295 fprintf(out, " -expiration '%s'", Time);
297 fprintf(out, " -lifetime %u", entryp->max_ticket_lifetime);
298 if (entryp->misc_auth_bytes[EXPIRES])
299 fprintf(out, " -pwexpires %u", entryp->misc_auth_bytes[EXPIRES]);
300 if (entryp->pwsums[0] || entryp->pwsums[1])
301 fprintf(out, " -reuse no");
302 if (entryp->misc_auth_bytes[ATTEMPTS])
303 fprintf(out, " -attempts %u", entryp->misc_auth_bytes[ATTEMPTS]);
304 if (entryp->misc_auth_bytes[LOCKTIME])
305 fprintf(out, " -locktime %d",
306 (int)(entryp->misc_auth_bytes[LOCKTIME] * 8.5));
309 fprintf(out, "setkey -name %s -new_key %s -kvno %d\n", principal, key,
310 ntohl(entryp->key_version));
314 struct kaheader *header;
316 afs_int32 i, code = 0;
318 header->version = ntohl(header->version);
319 header->headerSize = ntohl(header->headerSize);
320 header->freePtr = ntohl(header->freePtr);
321 header->eofPtr = ntohl(header->eofPtr);
322 header->kvnoPtr = ntohl(header->kvnoPtr);
323 header->stats.minor_version = ntohl(header->stats.minor_version);
324 header->stats.allocs = ntohl(header->stats.allocs);
325 header->stats.frees = ntohl(header->stats.frees);
326 header->stats.cpws = ntohl(header->stats.cpws);
327 header->admin_accounts = ntohl(header->admin_accounts);
328 header->specialKeysVersion = ntohl(header->specialKeysVersion);
329 header->hashsize = ntohl(header->hashsize);
330 for (i = 0; i < HASHSIZE; i++) {
331 header->nameHash[i] = ntohl(header->nameHash[i]);
333 header->checkVersion = ntohl(header->checkVersion);
335 if (header->version != header->checkVersion) {
337 fprintf(stderr, "HEADER VERSION MISMATCH: initial %d, final %d\n",
338 header->version, header->checkVersion);
340 if (header->headerSize != sizeof(struct kaheader)) {
343 "HEADER SIZE WRONG: file indicates %d, should be %d\n",
344 header->headerSize, sizeof(struct kaheader));
346 if (header->hashsize != HASHSIZE) {
348 fprintf(stderr, "HASH SIZE WRONG: file indicates %d, should be %d\n",
349 header->hashsize, HASHSIZE);
351 if ((header->kvnoPtr && ((header->kvnoPtr < header->headerSize)
352 || (header->eofPtr < header->freePtr)))
353 || (header->freePtr && ((header->freePtr < header->headerSize)
354 || (header->eofPtr < header->kvnoPtr)))) {
357 "DATABASE POINTERS BAD: header size = %d, freePtr = %d, kvnoPtr = %d, eofPtr = %d\n",
358 header->headerSize, header->freePtr, header->kvnoPtr,
363 * fprintf(stderr, "DB Version %d, %d possible entries\n", header->version,
364 * (header->eofPtr-header->headerSize) / sizeof(struct kaentry));
371 struct kaentry *entryp;
375 char *aname = entryp->userID.name;
376 char *ainstance = entryp->userID.instance;
378 /* stolen directly from the HashString function in the vol package */
380 for (i = strlen(aname), aname += i - 1; i--; aname--)
381 hash = (hash * 31) + (*((unsigned char *)aname) - 31);
382 for (i = strlen(ainstance), ainstance += i - 1; i--; ainstance--)
383 hash = (hash * 31) + (*((unsigned char *)ainstance) - 31);
384 return (hash % HASHSIZE);
387 readDB(offset, buffer, size)
394 offset += UBIK_HEADERSIZE;
395 code = lseek(fd, offset, SEEK_SET);
396 if (code != offset) {
397 afs_com_err(whoami, errno, "skipping Ubik header");
400 code = read(fd, buffer, size);
402 afs_com_err(whoami, errno, "reading db got %d bytes", code);
407 #include "AFS_component_version_number.c"
410 struct cmd_syndesc *as;
418 struct kaheader header;
419 int nentries, i, j, count;
421 struct kaentry entry;
423 dbFile = as->parms[0].items->data; /* -database */
424 listuheader = (as->parms[1].items ? 1 : 0); /* -uheader */
425 listkheader = (as->parms[2].items ? 1 : 0); /* -kheader */
426 listentries = (as->parms[3].items ? 1 : 0); /* -entries */
427 verbose = (as->parms[4].items ? 1 : 0); /* -verbose */
428 outFile = (as->parms[5].items ? as->parms[5].items->data : NULL); /* -rebuild */
431 out = fopen(outFile, "w");
433 afs_com_err(whoami, errno, "opening output file %s", outFile);
439 fd = open(dbFile, O_RDONLY, 0);
441 afs_com_err(whoami, errno, "opening database file %s", dbFile);
444 code = fstat(fd, &info);
446 afs_com_err(whoami, errno, "stat'ing file %s", dbFile);
449 if ((info.st_size - UBIK_HEADERSIZE) % UBIK_BUFFERSIZE)
451 "DATABASE SIZE INCONSISTENT: was %d, should be (n*%d + %d), for integral n\n",
452 info.st_size, UBIK_BUFFERSIZE, UBIK_HEADERSIZE);
456 readDB(0, &header, sizeof(header));
457 code = CheckHeader(&header);
459 PrintHeader(&header);
463 (UBIK_HEADERSIZE + header.headerSize)) / sizeof(struct kaentry);
464 entrys = (int *)malloc(nentries * sizeof(int));
465 memset(entrys, 0, nentries * sizeof(int));
467 for (i = 0, index = sizeof(header); i < nentries;
468 i++, index += sizeof(struct kaentry)) {
469 readDB(index, &entry, sizeof(entry));
471 if (index >= header.eofPtr) {
473 } else if (listentries) {
474 PrintEntry(index, &entry);
477 if (entry.flags & KAFNORMAL) {
478 entrys[i] |= 0x1; /* user entry */
480 if (strlen(entry.userID.name) == 0) {
482 printf("Entry %d has zero length name\n", i);
485 if (!des_check_key_parity(&entry.key)
486 || des_is_weak_key(&entry.key)) {
487 fprintf(stderr, "Entry %d, %s, has bad key\n", i,
493 RebuildEntry(&entry);
496 } else if (entry.flags & KAFFREE) {
497 entrys[i] |= 0x2; /* free entry */
499 } else if (entry.flags & KAFOLDKEYS) {
500 entrys[i] |= 0x4; /* old keys block */
501 /* Should check the structure of the oldkeys block? */
504 if (index < header.eofPtr) {
505 fprintf(stderr, "Entry %d is unrecognizable\n", i);
510 /* Follow the hash chains */
511 for (j = 0; j < HASHSIZE; j++) {
512 for (index = header.nameHash[j]; index; index = entry.next) {
513 readDB(index, &entry, sizeof(entry));
515 /* check to see if the name is hashed correctly */
516 i = NameHash(&entry);
519 "Entry %d, %s, found in hash chain %d (should be %d)\n",
521 sizeof(struct kaheader)) / sizeof(struct kaentry)),
522 EntryName(&entry), j, i);
525 /* Is it on another hash chain or circular hash chain */
526 i = (index - header.headerSize) / sizeof(entry);
527 if (entrys[i] & 0x10) {
529 "Entry %d, %s, hash index %d, was found on another hash chain\n",
530 i, EntryName(&entry), j);
532 fprintf(stderr, "Skipping rest of hash chain %d\n", j);
534 fprintf(stderr, "No next entry in hash chain %d\n", j);
538 entrys[i] |= 0x10; /* On hash chain */
542 /* Follow the free pointers */
544 for (index = header.freePtr; index; index = entry.next) {
545 readDB(index, &entry, sizeof(entry));
547 /* Is it on another chain or circular free chain */
548 i = (index - header.headerSize) / sizeof(entry);
549 if (entrys[i] & 0x20) {
550 fprintf(stderr, "Entry %d, %s, already found on free chain\n", i,
552 fprintf(stderr, "Skipping rest of free chain\n");
556 entrys[i] |= 0x20; /* On free chain */
561 printf("Found %d free entries\n", count);
563 /* Follow the oldkey blocks */
565 for (index = header.kvnoPtr; index; index = entry.next) {
566 readDB(index, &entry, sizeof(entry));
568 /* Is it on another chain or circular free chain */
569 i = (index - header.headerSize) / sizeof(entry);
570 if (entrys[i] & 0x40) {
571 fprintf(stderr, "Entry %d, %s, already found on olkeys chain\n",
572 i, EntryName(&entry));
573 fprintf(stderr, "Skipping rest of oldkeys chain\n");
577 entrys[i] |= 0x40; /* On free chain */
582 printf("Found %d oldkey blocks\n", count);
584 /* Now recheck all the blocks and see if they are allocated correctly
585 * 0x1 --> User Entry 0x10 --> On hash chain
586 * 0x2 --> Free Entry 0x20 --> On Free chain
587 * 0x4 --> OldKeys Entry 0x40 --> On Oldkeys chain
590 for (i = 0; i < nentries; i++) {
592 if (j & 0x1) { /* user entry */
594 badEntry(j, i); /* on hash chain? */
596 badEntry(j, i); /* anything else? */
597 } else if (j & 0x2) { /* free entry */
599 badEntry(j, i); /* on free chain? */
601 badEntry(j, i); /* anything else? */
602 } else if (j & 0x4) { /* oldkeys entry */
604 badEntry(j, i); /* on oldkeys chain? */
606 badEntry(j, i); /* anything else? */
607 } else if (j & 0x8) { /* past eof */
609 badEntry(j, i); /* anything else? */
611 badEntry(j, i); /* anything else? */
622 struct kaentry entry;
624 offset = i * sizeof(struct kaentry) + sizeof(struct kaheader);
625 readDB(offset, &entry, sizeof(entry));
627 fprintf(stderr, "Entry %d, %s, hash index %d, is bad: [", i,
628 EntryName(&entry), NameHash(&entry));
630 fprintf(stderr, " UserEntry");
632 fprintf(stderr, " FreeEntry");
634 fprintf(stderr, " OldkeysEntry");
636 fprintf(stderr, " PastEOF");
638 fprintf(stderr, " <NULL>");
639 fprintf(stderr, " ] [");
641 fprintf(stderr, " UserChain");
643 fprintf(stderr, " FreeChain");
645 fprintf(stderr, " OldkeysChain");
647 fprintf(stderr, " <NULL>");
648 fprintf(stderr, " ]\n");
655 struct cmd_syndesc *ts;
659 ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "KADB check");
660 cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "kadb_file");
661 cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
662 "Display UBIK header");
663 cmd_AddParm(ts, "-kheader", CMD_FLAG, CMD_OPTIONAL,
664 "Display KADB header");
665 cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
666 cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
667 cmd_AddParm(ts, "-rebuild", CMD_SINGLE, CMD_OPTIONAL, "out_file");
669 return cmd_Dispatch(argc, argv);