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