src/kauth/krb_udp.c

   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 /* This file contains the code to handle UDP requests to the authentication
  11    server using the MIT Kerberos protocol for obtaining tickets.  It will only
  12    handle authentication and get ticket requests to provide read-only protocol
  13    level compatibility with the standard Kerberos servers. */
  14
  15 #include <afsconfig.h>
  16 #include <afs/param.h>
  17 #include <afs/stds.h>
  18
  19 #include <roken.h>
  20
  21 #ifdef IGNORE_SOME_GCC_WARNINGS
  22 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
  23 #endif
  24
  25 #ifdef AFS_NT40_ENV
  26 #include <afs/errmap_nt.h>
  27 #endif
  28
  29 #define HC_DEPRECATED
  30 #include <hcrypto/des.h>
  31
  32 #include <afs/com_err.h>
  33 #include <lwp.h>
  34 #include <rx/xdr.h>
  35 #include <rx/rx.h>
  36 #include <rx/rxkad.h>
  37 #include <rx/rxkad_convert.h>
  38 #include <afs/auth.h>
  39 #include <ubik.h>
  40
  41 #include "kauth.h"
  42 #include "kautils.h"
  43 #include "kauth_internal.h"
  44 #include "kaserver.h"
  45 #include "prot.h"               /* protocol definitions */
  46 #include "kaport.h"
  47 #include "afs/audit.h"
  48 #include "kalog.h"
  49 #include "kadatabase.h"
  50
  51 /* my kerberos error codes */
  52 #define KERB_ERR_BAD_MSG_TYPE  99
  53 #define KERB_ERR_BAD_LIFETIME  98
  54 #define KERB_ERR_NONNULL_REALM 97
  55 #define KERB_ERR_PKT_LENGTH    96
  56 #define KERB_ERR_TEXT_LENGTH   95
  57 #ifndef KDC_GEN_ERR
  58 #define KDC_GEN_ERR     20
  59 #endif
  60
  61 #ifndef AFS_NT40_ENV
  62 #define closesocket close
  63 #endif
  64
  65 int krb_udp_debug = 0;
  66
  67 static int sock_kerb = -1;      /* the socket we're using */
  68 static int sock_kerb5 = -1;     /* the socket we're using */
  69
  70 struct packet {
  71     int len;
  72     struct sockaddr_in from;
  73     int byteOrder;
  74     char *name;
  75     char *inst;
  76     char *realm;
  77     Date time;
  78     char *rest;                 /* remaining bytes of packet */
  79     char data[MAX_PKT_LEN];
  80 };
  81
  82 extern char *lastOperation;
  83 extern char lrealm[];
  84
  85 char udpAuthPrincipal[256];
  86 char udptgsPrincipal[256];
  87 char udptgsServerPrincipal[256];
  88
  89 #define putstr(name) if ((slen = strlen(name)) >= MAXKTCNAMELEN) return -1;\
  90                      else strcpy (answer, name), answer += slen+1
  91 #define putint(num) num = htonl(num), \
  92                     memcpy(answer, &num, sizeof(afs_int32)), \
  93                     answer += sizeof(afs_int32)
  94
  95 #define getstr(name) if ((slen = strlen(packet)) >= sizeof(name)) return -1;\
  96                      strcpy (name, packet), packet += slen+1
  97 #define getint(num) memcpy(&num, packet, sizeof(afs_int32)), \
  98                     num = ktohl (byteOrder, num), \
  99                     packet += sizeof(afs_int32)
 100
 101 /* this is just to close the log every five minutes to rm works */
 102
 103 int fiveminutes = 300;
 104
 105 static void *
 106 FiveMinuteCheckLWP(void *unused)
 107 {
 108
 109     printf("start 5 min check lwp\n");
 110
 111     while (1) {
 112         IOMGR_Sleep(fiveminutes);
 113         /* close the log so it can be removed */
 114         ReOpenLog();    /* no trunc, just append */
 115     }
 116     return NULL;
 117 }
 118
 119
 120 static afs_int32
 121 create_cipher(char *cipher, int *cipherLen,
 122               struct ktc_encryptionKey *sessionKey, char *sname,
 123               char *sinst, Date start, Date end, afs_int32 kvno,
 124               char *ticket, int ticketLen, struct ktc_encryptionKey *key)
 125 {
 126     char *answer;
 127     int slen;
 128     unsigned char life = time_to_life(start, end);
 129     int len;
 130     DES_key_schedule schedule;
 131     afs_int32 code;
 132
 133     answer = cipher;
 134     len =
 135         sizeof(*sessionKey) + strlen(sname) + strlen(sinst) + strlen(lrealm) +
 136         3 /*nulls */  + 3 + ticketLen + sizeof(Date);
 137     if (len > *cipherLen)
 138         return KAANSWERTOOLONG;
 139     if (ticketLen > 255)
 140         return KAANSWERTOOLONG;
 141     if (kvno > 255)
 142         return KAANSWERTOOLONG;
 143
 144     memcpy(answer, sessionKey, sizeof(*sessionKey));
 145     answer += sizeof(*sessionKey);
 146     putstr(sname);
 147     putstr(sinst);
 148     putstr(lrealm);
 149     *answer++ = life;
 150     *answer++ = (unsigned char)kvno;
 151     *answer++ = (unsigned char)ticketLen;
 152     memcpy(answer, ticket, ticketLen);
 153     answer += ticketLen;
 154     putint(start);
 155
 156     if (krb_udp_debug) {
 157         printf("Printing ticket (%d) and date: ", ticketLen);
 158         ka_PrintBytes(ticket, ticketLen);
 159         ka_PrintBytes(answer - 4, 4);
 160         printf("\n");
 161     }
 162
 163     if ((code = DES_key_sched(ktc_to_cblock(key), &schedule)))
 164         printf("In KAAuthenticate: key_sched returned %d\n", code);
 165     DES_pcbc_encrypt(cipher, cipher, len, &schedule, ktc_to_cblockptr(key), ENCRYPT);
 166     *cipherLen = round_up_to_ebs(len);
 167
 168     if (krb_udp_debug) {
 169         printf("Printing cipher (%d): ", *cipherLen);
 170         ka_PrintBytes(cipher, *cipherLen);
 171         printf("\n");
 172     }
 173     return 0;
 174 }
 175
 176 static afs_int32
 177 create_reply(struct packet *ans, char *name, char *inst, Date startTime,
 178              Date endTime, afs_int32 kvno, char *cipher, int cipherLen)
 179 {
 180     char *answer = ans->data;
 181     int slen;
 182
 183     ans->len = 2 + strlen(name) + strlen(inst) + 3 /*nulls */  +
 184         sizeof(afs_int32) + 1 /*ntkts */  + sizeof(afs_int32) + 1 /*kvno */  +
 185         sizeof(short) + cipherLen;
 186     if (ans->len > sizeof(ans->data))
 187         return KAANSWERTOOLONG;
 188     if (kvno > 255)
 189         return KAANSWERTOOLONG;
 190
 191     *answer++ = (unsigned char)KRB_PROT_VERSION;
 192     *answer++ = (unsigned char)AUTH_MSG_KDC_REPLY;
 193     /* always send claiming network byte order */
 194     putstr(name);
 195     putstr(inst);
 196     putstr("");
 197     putint(startTime);
 198     *answer++ = 1;              /* undocumented number of tickets! */
 199     putint(endTime);
 200     *answer++ = (unsigned char)kvno;
 201     {
 202         short w = (short)cipherLen;
 203         w = htons(w);
 204         memcpy(answer, &w, sizeof(short));
 205         answer += sizeof(short);
 206     }
 207     memcpy(answer, cipher, cipherLen);
 208     return 0;
 209 }
 210
 211 static afs_int32
 212 check_auth(struct packet *pkt, char *auth, int authLen,
 213            struct ktc_encryptionKey *key, char *name, char *inst,
 214            char *cell)
 215 {
 216     char *packet;
 217     DES_key_schedule schedule;
 218     afs_int32 cksum;
 219     afs_int32 time_sec;
 220     int byteOrder = pkt->byteOrder;
 221
 222     DES_key_sched(ktc_to_cblock(key), &schedule);
 223     DES_pcbc_encrypt(auth, auth, authLen, &schedule, ktc_to_cblockptr(key), DECRYPT);
 224     packet = auth;
 225     if (strcmp(packet, name) != 0)
 226         return KABADTICKET;
 227     packet += strlen(packet) + 1;
 228     if (strcmp(packet, inst) != 0)
 229         return KABADTICKET;
 230     packet += strlen(packet) + 1;
 231     if (strcmp(packet, cell) != 0)
 232         return KABADTICKET;
 233     packet += strlen(packet) + 1;
 234     getint(cksum);
 235     /* Comments in the original IBM source suggest this byte was/is "time_msec" */
 236     packet++;
 237     getint(time_sec);
 238     if ((packet - auth) > authLen)
 239         return KABADTICKET;
 240     return 0;
 241 }
 242
 243 afs_int32
 244 UDP_Authenticate(int ksoc, struct sockaddr_in *client, char *name,
 245                  char *inst, Date startTime, Date endTime, char *sname,
 246                  char *sinst)
 247 {
 248     struct ubik_trans *tt;
 249     afs_int32 to;               /* offset of block */
 250     struct kaentry tentry;
 251     afs_int32 tgskvno;          /* key version of service key */
 252     struct ktc_encryptionKey tgskey;    /* service key for encrypting ticket */
 253     int tgt;
 254     Date now = time(0);
 255     afs_int32 code;
 256
 257     char ticket[MAXKTCTICKETLEN];       /* our copy of the ticket */
 258     int ticketLen;
 259     struct ktc_encryptionKey sessionKey;        /* we have to invent a session key */
 260
 261     char cipher[2 * MAXKTCTICKETLEN];   /* put encrypted part of answer here */
 262     int cipherLen;
 263     struct packet ans;
 264
 265     COUNT_REQ(UAuthenticate);
 266     if (!name_instance_legal(name, inst))
 267         return KERB_ERR_NAME_EXP;       /* KABADNAME */
 268     if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
 269         return code;
 270
 271     code = FindBlock(tt, name, inst, &to, &tentry);
 272     if (code)
 273         goto abort;
 274     if (to) {                   /* if user exists check other stuff */
 275         afs_int32 sto;
 276         struct kaentry sentry;
 277
 278         unsigned char misc_auth_bytes[4];
 279         afs_uint32 temp;        /* unsigned for safety */
 280         afs_uint32 pwexpires;
 281
 282         save_principal(udpAuthPrincipal, name, inst, 0);
 283
 284         tgt = ((strcmp(sname, KA_TGS_NAME) == 0)
 285                && (strcmp(sinst, lrealm) == 0));
 286         if ((ntohl(tentry.user_expiration) < now)
 287             || (tgt && (ntohl(tentry.flags) & KAFNOTGS))) {
 288             code = KERB_ERR_NAME_EXP;   /* KABADUSER */
 289             goto abort;
 290         }
 291         code = FindBlock(tt, KA_TGS_NAME, lrealm, &sto, &sentry);
 292         if (code)
 293             goto abort;
 294         if (sto == 0) {
 295             code = KANOENT;
 296             goto abort;
 297         }
 298         if ((ntohl(sentry.user_expiration) < now)) {
 299             code = KERB_ERR_NAME_EXP;   /* XXX Could use another error code XXX */
 300             goto abort;
 301         }
 302         if (check_ka_skew(startTime, now, KTC_TIME_UNCERTAINTY)) {
 303             code = KERB_ERR_SERVICE_EXP;        /* was KABADREQUEST */
 304             goto abort;
 305         }
 306
 307         memcpy(&temp, tentry.misc_auth_bytes, sizeof(afs_uint32));
 308         temp = ntohl(temp);
 309         unpack_long(temp, misc_auth_bytes);
 310         pwexpires = misc_auth_bytes[0];
 311         if (pwexpires) {
 312             pwexpires =
 313                 ntohl(tentry.change_password_time) +
 314                 24 * 60 * 60 * pwexpires;
 315             if (pwexpires < now) {
 316                 code = KERB_ERR_AUTH_EXP;       /* was KAPWEXPIRED */
 317                 goto abort;
 318             }
 319         }
 320
 321         /* make the ticket */
 322         code = DES_new_random_key(ktc_to_cblock(&sessionKey));
 323         if (code) {
 324             code = KERB_ERR_NULL_KEY;   /* was KANOKEYS */
 325             goto abort;
 326         }
 327         endTime =
 328             umin(endTime, startTime + ntohl(tentry.max_ticket_lifetime));
 329         if ((code = ka_LookupKey(tt, sname, sinst, &tgskvno, &tgskey))
 330             || (code =
 331                 tkt_MakeTicket(ticket, &ticketLen, &tgskey, name, inst,
 332                                lrealm, startTime, endTime, &sessionKey,
 333                                htonl(client->sin_addr.s_addr), sname, sinst)))
 334             goto abort;
 335
 336         cipherLen = sizeof(cipher);
 337         code =
 338             create_cipher(cipher, &cipherLen, &sessionKey, sname, sinst,
 339                           startTime, endTime, tgskvno, ticket, ticketLen,
 340                           &tentry.key);
 341         if (code)
 342             goto abort;
 343     } else {                    /* no such user */
 344         cipherLen = 0;
 345         tentry.key_version = 0;
 346     }
 347     code = ubik_EndTrans(tt);
 348     if (code)
 349         goto fail;
 350
 351     code =
 352         create_reply(&ans, name, inst, startTime, endTime,
 353                      ntohl(tentry.key_version), cipher, cipherLen);
 354     if (code)
 355         goto fail;
 356
 357     if (krb_udp_debug) {
 358         printf("Sending %d bytes ending in: ", ans.len);
 359         ka_PrintBytes(ans.data + ans.len - 8, 8);
 360         printf("\n");
 361     }
 362
 363     code =
 364         sendto(ksoc, ans.data, ans.len, 0, (struct sockaddr *)client,
 365                sizeof(*client));
 366     if (code != ans.len) {
 367         perror("calling sendto");
 368         code = -1;
 369         goto fail;
 370     }
 371     KALOG(name, inst, sname, sinst, NULL, client->sin_addr.s_addr,
 372           LOG_AUTHENTICATE);
 373
 374     if (cipherLen != 0) {
 375         KALOG(name, inst, sname, sinst, NULL, client->sin_addr.s_addr,
 376               LOG_TGTREQUEST);
 377     }
 378     osi_audit(UDPAuthenticateEvent, 0, AUD_STR, name, AUD_STR, inst, AUD_END);
 379     return 0;
 380
 381   abort:
 382     COUNT_ABO;
 383     ubik_AbortTrans(tt);
 384
 385   fail:
 386     osi_audit(UDPAuthenticateEvent, code, AUD_STR, name, AUD_STR, inst,
 387               AUD_END);
 388     return code;
 389 }
 390
 391 afs_int32
 392 UDP_GetTicket(int ksoc, struct packet *pkt, afs_int32 kvno,
 393               char *authDomain, char *ticket, int ticketLen, char *auth,
 394               int authLen)
 395 {
 396     afs_int32 code;
 397     struct ktc_encryptionKey tgskey;
 398     char name[MAXKTCNAMELEN];
 399     char inst[MAXKTCNAMELEN];
 400     char cell[MAXKTCREALMLEN];
 401     struct ktc_encryptionKey authSessionKey;
 402     afs_int32 host;
 403     Date start;
 404     Date authEnd;
 405     Date now = time(0);
 406     int celllen;
 407     int import;
 408
 409     char *packet;
 410     int slen;
 411     int byteOrder = pkt->byteOrder;
 412     char sname[MAXKTCNAMELEN];
 413     char sinst[MAXKTCNAMELEN];
 414     afs_int32 time_ws;
 415     unsigned char life;
 416
 417     struct ubik_trans *tt;
 418     afs_int32 to;
 419     struct kaentry caller;
 420     struct kaentry server;
 421     Date reqEnd;
 422     struct ktc_encryptionKey sessionKey;
 423     int newTicketLen;
 424     char newTicket[MAXKTCTICKETLEN];
 425
 426     char cipher[2 * MAXKTCTICKETLEN];   /* put encrypted part of answer here */
 427     int cipherLen;
 428     struct packet ans;
 429
 430     COUNT_REQ(UGetTicket);
 431
 432     if ((code = InitAuthServ(&tt, LOCKREAD, this_op)))
 433         goto fail;
 434     code =
 435         ka_LookupKvno(tt, KA_TGS_NAME,
 436                       ((strlen(authDomain) > 0) ? authDomain : lrealm), kvno,
 437                       &tgskey);
 438     if (code)
 439         goto abort;
 440
 441     code =
 442         tkt_DecodeTicket(ticket, ticketLen, &tgskey, name, inst, cell,
 443                          &authSessionKey, &host, &start, &authEnd);
 444     pkt->name = name;
 445     pkt->inst = inst;
 446     pkt->realm = cell;
 447     if (code) {
 448         code = KERB_ERR_AUTH_EXP;       /* was KANOAUTH */
 449         goto abort;
 450     }
 451     save_principal(udptgsPrincipal, name, inst, cell);
 452     code = tkt_CheckTimes(start, authEnd, now);
 453     if (code <= 0) {
 454         if (code == -1) {
 455             code = KERB_ERR_SERVICE_EXP;        /* was RXKADEXPIRED */
 456             goto abort;
 457         }
 458         code = KERB_ERR_AUTH_EXP;       /* was KANOAUTH */
 459         goto abort;
 460     }
 461     celllen = strlen(cell);
 462     import = 0;
 463     if ((strlen(authDomain) > 0) && (strcmp(authDomain, lrealm) != 0))
 464         import = 1;
 465     if (import && (celllen == 0)) {
 466         code = KERB_ERR_PKT_VER;        /* was KABADTICKET */
 467         goto abort;
 468     }
 469     if (celllen == 0) {
 470         strncpy(cell, lrealm, MAXKTCREALMLEN - 1);
 471         cell[MAXKTCREALMLEN - 1] = 0;
 472     };
 473
 474     if (!krb4_cross && strcmp(lrealm, cell) != 0) {
 475         code = KERB_ERR_PRINCIPAL_UNKNOWN;
 476         goto abort;
 477     }
 478
 479     if (krb_udp_debug) {
 480         printf("UGetTicket: got ticket from '%s'.'%s'@'%s'\n", name, inst,
 481                cell);
 482     }
 483
 484     code = check_auth(pkt, auth, authLen, &authSessionKey, name, inst, cell);
 485     if (code)
 486         goto abort;
 487
 488     /* authenticator and all is OK so read actual request */
 489     packet = pkt->rest;
 490     getint(time_ws);
 491     life = *(unsigned char *)packet++;
 492     getstr(sname);
 493     getstr(sinst);
 494     start = now;
 495     reqEnd = life_to_time(start, life);
 496     if (krb_udp_debug) {
 497         printf("UGetTicket: request for server '%s'.'%s'\n", sname, sinst);
 498     }
 499     save_principal(udptgsServerPrincipal, sname, sinst, 0);
 500
 501     if (import) {
 502         strcpy(caller.userID.name, name);
 503         strcpy(caller.userID.instance, inst);
 504         caller.max_ticket_lifetime = htonl(MAXKTCTICKETLIFETIME);
 505     } else {
 506         code = FindBlock(tt, name, inst, &to, &caller);
 507         if (code)
 508             goto abort;
 509         if (to == 0) {
 510             ka_PrintUserID("GetTicket: User ", name, inst, " unknown.\n");
 511             code = KERB_ERR_PRINCIPAL_UNKNOWN;  /* KANOENT */
 512             goto abort;
 513         }
 514         if (ntohl(caller.flags) & KAFNOTGS) {
 515             code = KERB_ERR_AUTH_EXP;   /* was KABADUSER */
 516             goto abort;
 517         }
 518     }
 519
 520     code = FindBlock(tt, sname, sinst, &to, &server);   /* get server's entry */
 521     if (code)
 522         goto abort;
 523     if (to == 0) {              /* entry not found */
 524         ka_PrintUserID("GetTicket: Server ", sname, sinst, " unknown.\n");
 525         code = KERB_ERR_PRINCIPAL_UNKNOWN;      /* KANOENT */
 526         goto abort;
 527     }
 528     code = ubik_EndTrans(tt);
 529     if (code)
 530         goto fail;
 531
 532     if (ntohl(server.flags) & KAFNOSEAL)
 533         return KABADSERVER;
 534
 535     code = DES_new_random_key(ktc_to_cblock(&sessionKey));
 536     if (code) {
 537         code = KERB_ERR_NULL_KEY;       /* was KANOKEYS */
 538         goto fail;
 539     }
 540
 541     reqEnd =
 542         umin(umin(reqEnd, authEnd),
 543              umin(start + ntohl(caller.max_ticket_lifetime),
 544                   start + ntohl(server.max_ticket_lifetime)));
 545
 546     code =
 547         tkt_MakeTicket(newTicket, &newTicketLen, &server.key,
 548                        caller.userID.name, caller.userID.instance, cell,
 549                        start, reqEnd, &sessionKey,
 550                        htonl(pkt->from.sin_addr.s_addr), server.userID.name,
 551                        server.userID.instance);
 552     if (code)
 553         goto fail;
 554
 555     cipherLen = sizeof(cipher);
 556     code =
 557         create_cipher(cipher, &cipherLen, &sessionKey, sname, sinst, start,
 558                       reqEnd, ntohl(server.key_version), newTicket,
 559                       newTicketLen, &authSessionKey);
 560     if (code)
 561         goto fail;
 562
 563     code =
 564         create_reply(&ans, name, inst, start, reqEnd, 0, cipher, cipherLen);
 565     if (code)
 566         goto fail;
 567
 568     code =
 569         sendto(ksoc, ans.data, ans.len, 0, (struct sockaddr *)&pkt->from,
 570                sizeof(pkt->from));
 571     if (code != ans.len) {
 572         perror("calling sendto");
 573         code = -1;
 574         goto fail;
 575     }
 576
 577     if (cipherLen != 0) {
 578         KALOG(name, inst, sname, sinst, NULL, host, LOG_GETTICKET);
 579     }
 580     osi_audit(UDPGetTicketEvent, 0, AUD_STR, name, AUD_STR, inst, AUD_STR,
 581               cell, AUD_STR, sname, AUD_STR, sinst, AUD_END);
 582     return 0;
 583
 584   abort:
 585     ubik_AbortTrans(tt);
 586   fail:
 587     osi_audit(UDPGetTicketEvent, code, AUD_STR, name, AUD_STR, inst, AUD_STR,
 588               NULL, AUD_STR, NULL, AUD_STR, NULL, AUD_END);
 589     return code;
 590 }
 591
 592 static int
 593 err_packet(int ksoc, struct packet *pkt, afs_int32 code, char *reason)
 594 {
 595     struct packet ans;
 596     char *answer = ans.data;
 597     int slen;
 598     char buf[256];
 599
 600     if (reason == 0)
 601         reason = "";
 602     snprintf(buf, 255, "code = %d: %s", code, reason);
 603
 604     if (krb_udp_debug) {
 605         printf("Sending error packet to '%s'.'%s'@'%s' containing %s\n",
 606                pkt->name, pkt->inst, pkt->realm, buf);
 607     }
 608
 609     ans.len =
 610         2 + strlen(pkt->name) + strlen(pkt->inst) + strlen(pkt->realm) +
 611         3 /* nulls */  + (2 * sizeof(afs_int32)) + strlen(buf) + 1;
 612     if (ans.len > sizeof(ans.data)) {
 613         printf("Answer packet too long\n");
 614         return -1;
 615     }
 616
 617     *answer++ = (unsigned char)KRB_PROT_VERSION;
 618     *answer++ = (unsigned char)AUTH_MSG_ERR_REPLY;
 619     /* always send claiming network byte order */
 620     putstr(pkt->name);
 621     putstr(pkt->inst);
 622     putstr(pkt->realm);
 623     putint(pkt->time);
 624     if ((code < 0) || (code > KERB_ERR_MAXIMUM)) {
 625         /* It could be because of kauth errors so we should return something instead of success!! */
 626         code = KDC_GEN_ERR;
 627     }
 628     putint(code);
 629     putstr(buf);
 630
 631     code =
 632         sendto(ksoc, ans.data, ans.len, 0, (struct sockaddr *)&pkt->from,
 633                sizeof(pkt->from));
 634     if (code != ans.len) {
 635         if (code >= 0)
 636             printf
 637                 ("call to sendto returned %d, sending error packet %d bytes long\n",
 638                  code, ans.len);
 639         else
 640             perror("err_packet: sendto");
 641     }
 642     return 0;
 643 }
 644
 645 int
 646 process_udp_auth(int ksoc, struct packet *pkt)
 647 {
 648     char *packet = pkt->rest;
 649     char name[MAXKTCNAMELEN];
 650     char inst[MAXKTCNAMELEN];
 651     char realm[MAXKTCREALMLEN];
 652     char sname[MAXKTCNAMELEN];
 653     char sinst[MAXKTCNAMELEN];
 654     int slen;
 655     Date now = time(0);
 656     Date startTime, endTime;
 657     unsigned char lifetime;
 658     afs_int32 code;
 659
 660     pkt->name = packet;
 661     getstr(name);
 662     pkt->inst = packet;
 663     getstr(inst);
 664     pkt->realm = packet;
 665     getstr(realm);
 666     if (krb_udp_debug) {
 667         printf("Processing KDC Request from '%s'.'%s'@'%s'\n", name, inst,
 668                realm);
 669     }
 670
 671     if ((strlen(realm) > 0) && (strcmp(realm, lrealm) != 0)) {
 672         err_packet(ksoc, pkt, KERB_ERR_NONNULL_REALM,
 673                    "null realm name not allowed");
 674         return -1;
 675     }
 676     memcpy(&startTime, packet, sizeof(startTime));
 677     packet += sizeof(startTime);
 678     startTime = ktohl(pkt->byteOrder, startTime);
 679     pkt->time = startTime;
 680     lifetime = *packet++;
 681     endTime = life_to_time(startTime, lifetime);
 682     code = tkt_CheckTimes(startTime, endTime, now);
 683     if (code < 0) {
 684         err_packet(ksoc, pkt, KERB_ERR_BAD_LIFETIME,
 685                    "requested ticket lifetime invalid");
 686         return -1;
 687     }
 688     getstr(sname);
 689     getstr(sinst);
 690     if ((packet - pkt->data) != pkt->len) {
 691         err_packet(ksoc, pkt, KERB_ERR_PKT_LENGTH,
 692                    "packet length inconsistent");
 693         return -1;
 694     }
 695     pkt->rest = packet;
 696     code =
 697         UDP_Authenticate(ksoc, &pkt->from, name, inst, startTime, endTime,
 698                          sname, sinst);
 699     if (code) {
 700         if (code == KANOENT) {
 701             code = KERB_ERR_PRINCIPAL_UNKNOWN;
 702             err_packet(ksoc, pkt, code, (char *)afs_error_message(code));
 703         } else if (code == KAPWEXPIRED) {
 704             code = KERB_ERR_NAME_EXP;
 705             err_packet(ksoc, pkt, code, "password has expired");
 706         } else
 707             err_packet(ksoc, pkt, code, (char *)afs_error_message(code));
 708     }
 709     return 0;
 710 }
 711
 712 int
 713 process_udp_appl(int ksoc, struct packet *pkt)
 714 {
 715     char *packet = pkt->rest;
 716     afs_int32 kvno;
 717     char realm[MAXKTCREALMLEN];
 718     char ticket[MAXKTCTICKETLEN];
 719     char auth[3 * MAXKTCNAMELEN + 4 + 5];
 720     int slen;
 721     int ticketLen, authLen;
 722     afs_int32 code;
 723
 724     if (krb_udp_debug) {
 725         printf("Processing APPL Request\n");
 726     }
 727     kvno = *packet++;
 728     getstr(realm);
 729     ticketLen = *(unsigned char *)packet++;
 730     authLen = *(unsigned char *)packet++;
 731     if (ticketLen > sizeof(ticket)) {
 732         err_packet(ksoc, pkt, KERB_ERR_TEXT_LENGTH, "ticket too long");
 733         return -1;
 734     }
 735     memcpy(ticket, packet, ticketLen);
 736     packet += ticketLen;
 737     if (authLen > sizeof(auth)) {
 738         err_packet(ksoc, pkt, KERB_ERR_TEXT_LENGTH, "authenticator too long");
 739         return -1;
 740     }
 741     memcpy(auth, packet, authLen);
 742     pkt->rest = packet + authLen;
 743     code =
 744         UDP_GetTicket(ksoc, pkt, kvno, realm, ticket, ticketLen, auth,
 745                       authLen);
 746     if (code) {
 747         if (code == KANOENT)
 748             code = KERB_ERR_PRINCIPAL_UNKNOWN;
 749         err_packet(ksoc, pkt, code, (char *)afs_error_message(code));
 750         return -1;
 751     }
 752     return 0;
 753 }
 754
 755 void
 756 process_udp_request(int ksoc, struct packet *pkt)
 757 {
 758     char *packet = pkt->data;
 759     unsigned char version, auth_msg_type;
 760
 761     version = *packet++;
 762     if (version != KRB_PROT_VERSION) {
 763         err_packet(ksoc, pkt, KERB_ERR_PKT_VER,
 764                    "packet version number unknown");
 765         return;
 766     }
 767     auth_msg_type = *packet++;
 768     pkt->byteOrder = auth_msg_type & 1;
 769     pkt->rest = packet;
 770     switch (auth_msg_type & ~1) {
 771     case AUTH_MSG_KDC_REQUEST:
 772         process_udp_auth(ksoc, pkt);
 773         break;
 774     case AUTH_MSG_APPL_REQUEST:
 775         process_udp_appl(ksoc, pkt);
 776         break;
 777     default:
 778         printf("unknown msg type 0x%x\n", auth_msg_type);
 779         err_packet(ksoc, pkt, KERB_ERR_BAD_MSG_TYPE,
 780                    "message type not supported");
 781         return;
 782     }
 783     return;
 784 }
 785
 786 static void *
 787 SocketListener(void *unused)
 788 {
 789     fd_set rfds;
 790     struct timeval tv;
 791     struct packet packet;
 792     socklen_t fromLen;
 793     afs_int32 code;
 794     char hoststr[16];
 795
 796     printf("Starting to listen for UDP packets\n");
 797     while (1) {
 798         FD_ZERO(&rfds);
 799         if (sock_kerb >= 0)
 800             FD_SET(sock_kerb, &rfds);
 801         if (sock_kerb5 >= 0)
 802             FD_SET(sock_kerb5, &rfds);
 803
 804         tv.tv_sec = 100;
 805         tv.tv_usec = 0;
 806         /* write and exception fd_set's are null */
 807         code = IOMGR_Select(32, &rfds, NULL, NULL, &tv);
 808         if (code == 0) {        /* timeout */
 809             /* printf ("Timeout\n"); */
 810             continue;
 811         } else if (code < 0) {
 812             perror("calling IOMGR_Select");
 813             break;
 814         }
 815
 816         fromLen = sizeof(packet.from);
 817         if ((sock_kerb >= 0) && FD_ISSET(sock_kerb, &rfds)) {
 818             code =
 819                 recvfrom(sock_kerb, packet.data, sizeof(packet.data), 0,
 820                          (struct sockaddr *)&packet.from, &fromLen);
 821             if (code < 0) {
 822                 if (errno == EAGAIN || errno == ECONNREFUSED)
 823                     goto try_kerb5;
 824                 perror("calling recvfrom");
 825                 break;
 826             }
 827             packet.len = code;
 828             if (krb_udp_debug) {
 829                 printf("Kerb:udp: Got %d bytes from addr %s which are '",
 830                        code, afs_inet_ntoa_r(packet.from.sin_addr.s_addr, hoststr));
 831                 ka_PrintBytes(packet.data, packet.len);
 832                 printf("'\n");
 833             }
 834             packet.name = packet.inst = packet.realm = "";
 835             packet.time = 0;
 836             process_udp_request(sock_kerb, &packet);
 837         }
 838       try_kerb5:
 839         if ((sock_kerb5 >= 0) && FD_ISSET(sock_kerb5, &rfds)) {
 840             code =
 841                 recvfrom(sock_kerb5, packet.data, sizeof(packet.data), 0,
 842                          (struct sockaddr *)&packet.from, &fromLen);
 843             if (code < 0) {
 844                 if (errno == EAGAIN || errno == ECONNREFUSED)
 845                     continue;
 846                 perror("calling recvfrom");
 847                 break;
 848             }
 849             packet.len = code;
 850             if (krb_udp_debug) {
 851                 printf("Kerb5:udp: Got %d bytes from addr %s which are '",
 852                        code, afs_inet_ntoa_r(packet.from.sin_addr.s_addr, hoststr));
 853                 ka_PrintBytes(packet.data, packet.len);
 854                 printf("'\n");
 855             }
 856             packet.name = packet.inst = packet.realm = "";
 857             packet.time = 0;
 858             process_udp_request(sock_kerb5, &packet);
 859         }
 860     }
 861     if (sock_kerb >= 0) {
 862         closesocket(sock_kerb);
 863         sock_kerb = -1;
 864     }
 865     if (sock_kerb5 >= 0) {
 866         closesocket(sock_kerb5);
 867         sock_kerb5 = -1;
 868     }
 869     printf("UDP SocketListener exiting due to error\n");
 870
 871     return NULL;
 872 }
 873
 874 #if MAIN
 875
 876 #include "AFS_component_version_number.c"
 877
 878 int
 879 main(int, char **)
 880 #else
 881 afs_int32
 882 init_krb_udp(void)
 883 #endif
 884 {
 885     struct sockaddr_in taddr;
 886     static PROCESS slPid;       /* socket listener pid */
 887     static PROCESS checkPid;    /* fiveminute check */
 888     afs_int32 code;
 889     char *krb4name;             /* kerberos version4 service */
 890
 891 #if MAIN
 892     PROCESS junk;
 893 #endif
 894     struct servent *sp;
 895     static int inited = 0;
 896     afs_int32 kerb_port;
 897
 898     if (inited)
 899         return -1;
 900     inited = 1;
 901
 902     memset(&taddr, 0, sizeof(taddr));
 903     krb4name = "kerberos4";
 904     sp = getservbyname(krb4name, "udp");
 905     taddr.sin_family = AF_INET; /* added for NCR port */
 906 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
 907     taddr.sin_len = sizeof(struct sockaddr_in);
 908 #endif
 909     if (!sp) {
 910         /* if kerberos-4 is not available, try "kerberos-iv" */
 911         krb4name = "kerberos-iv";
 912         sp = getservbyname(krb4name, "udp");
 913     }
 914     if (!sp) {
 915         /* if kerberos-iv is not available, try "kerberos" */
 916         krb4name = "kerberos";
 917         sp = getservbyname(krb4name, "udp");
 918     }
 919     if (!sp) {
 920         fprintf(stderr,
 921                 "kerberos/udp is unknown; check /etc/services.  Using port=%d as default\n",
 922                 KRB_PORT);
 923         taddr.sin_port = htons(KRB_PORT);
 924     } else {
 925         /* copy the port number */
 926         fprintf(stderr, "%s/udp port=%hu\n", krb4name,
 927                 (unsigned short)sp->s_port);
 928         taddr.sin_port = sp->s_port;
 929     }
 930     kerb_port = taddr.sin_port;
 931     sock_kerb = socket(AF_INET, SOCK_DGRAM, 0);
 932     code = bind(sock_kerb, (struct sockaddr *)&taddr, sizeof(taddr));
 933     if (code < 0) {
 934         perror("calling bind");
 935         sock_kerb = -1;
 936     }
 937
 938     sp = getservbyname("kerberos5", "udp");
 939     if (!sp) {
 940         fprintf(stderr,
 941                 "kerberos5/udp is unknown; check /etc/services.  Using port=%d as default\n",
 942                 KRB5_PORT);
 943         taddr.sin_port = htons(KRB5_PORT);
 944     } else {
 945         /* copy the port number */
 946         fprintf(stderr, "kerberos5/udp port=%hu\n",
 947                 (unsigned short)sp->s_port);
 948         taddr.sin_port = sp->s_port;
 949     }
 950     if (taddr.sin_port != kerb_port) {  /* a different port */
 951         sock_kerb5 = socket(AF_INET, SOCK_DGRAM, 0);
 952         code = bind(sock_kerb5, (struct sockaddr *)&taddr, sizeof(taddr));
 953         if (code < 0) {
 954             perror("calling bind");
 955             sock_kerb5 = -1;
 956         }
 957     }
 958
 959     /* Bail out if we can't bind with any port */
 960     if ((sock_kerb < 0) && (sock_kerb5 < 0))
 961         return -1;
 962
 963 #if MAIN
 964     /* this has already been done */
 965     LWP_InitializeProcessSupport(LWP_NORMAL_PRIORITY, &junk);
 966     IOMGR_Initialize();
 967 #endif
 968     LWP_CreateProcess(SocketListener, /*stacksize */ 16000,
 969                       LWP_NORMAL_PRIORITY, (void *)0, "Socket Listener",
 970                       &slPid);
 971
 972     /* just to close the log every five minutes */
 973
 974     LWP_CreateProcess(FiveMinuteCheckLWP, 24 * 1024, LWP_MAX_PRIORITY - 2,
 975                       (void *)&fiveminutes, "FiveMinuteChecks", &checkPid);
 976
 977 #if MAIN
 978     initialize_ka_error_table();
 979     initialize_rxk_error_table();
 980     while (1)                   /* don't just stand there, run it */
 981         IOMGR_Sleep(60);
 982 #else
 983     return 0;
 984 #endif
 985
 986 }
 987
 988 #if MAIN
 989 char *lastOperation;            /* name of last operation */
 990 char *lrealm = "REALMNAME";
 991 struct kadstats dynamic_statistics;
 992
 993 static int
 994 InitAuthServ(tt, lock, this_op)
 995      struct ubik_trans **tt;
 996      int lock;                  /* read or write transaction */
 997      int *this_op;              /* op of RCP routine, for COUNT_ABO */
 998 {
 999     int code = 0;
1000
1001     *tt = 0;
1002     printf("Calling InitAuthServ\n");
1003     return code;
1004 }
1005
1006 static int
1007 ubik_EndTrans(tt)
1008      struct ubik_trans *tt;
1009 {
1010     printf("Calling ubik_EndTrans\n");
1011     return 0;
1012 }
1013
1014 static int
1015 ubik_AbortTrans(tt)
1016      struct ubik_trans *tt;
1017 {
1018     printf("Calling ubik_AbortTrans\n");
1019     return 0;
1020 }
1021
1022 static int
1023 FindBlock(at, aname, ainstance, tentry)
1024      struct ubik_trans *at;
1025      char *aname;
1026      char *ainstance;
1027      struct kaentry *tentry;
1028 {
1029     printf("Calling FindBlock with '%s'.'%s'\n", aname, ainstance);
1030     strcpy(tentry->userID.name, aname);
1031     strcpy(tentry->userID.instance, ainstance);
1032     tentry->key_version = htonl(17);
1033     DES_string_to_key("toa", &tentry->key);
1034     tentry->flags = htonl(KAFNORMAL);
1035     tentry->user_expiration = htonl(NEVERDATE);
1036     tentry->max_ticket_lifetime = htonl(MAXKTCTICKETLIFETIME);
1037     return 323232;
1038 }
1039
1040 static int
1041 ka_LookupKey(tt, name, inst, kvno, key)
1042      struct ubik_trans *tt;
1043      char *name;
1044      char *inst;
1045      afs_int32 *kvno;           /* returned */
1046      struct ktc_encryptionKey *key;     /* copied out */
1047 {
1048     printf("Calling ka_LookupKey with '%s'.'%s'\n", name, inst);
1049     *kvno = 23;
1050     DES_string_to_key("applexx", key);
1051 }
1052
1053 static afs_int32
1054 kvno_tgs_key(authDomain, kvno, tgskey)
1055      char *authDomain;
1056      afs_int32 kvno;
1057      struct ktc_encryptionKey *tgskey;
1058 {
1059     if (strcmp(authDomain, lrealm) != 0)
1060         printf("Called with wrong %s as authDomain\n", authDomain);
1061     if (kvno != 23)
1062         printf("kvno_tgs_key: being called with wrong kvno: %d\n", kvno);
1063     DES_string_to_key("applexx", tgskey);
1064     return 0;
1065 }
1066
1067 save_principal()
1068 {
1069 }
1070
1071 name_instance_legal()
1072 {
1073     return 1;
1074 }
1075 #endif