etc/afpd/auth.c

   1 /*
   2  * $Id: auth.c,v 1.19.2.3 2002-03-05 02:08:12 jmarcus Exp $
   3  *
   4  * Copyright (c) 1990,1993 Regents of The University of Michigan.
   5  * All Rights Reserved.  See COPYRIGHT.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <errno.h>
  15 #ifdef HAVE_UNISTD_H
  16 #include <unistd.h>
  17 #endif /* HAVE_UNISTD_H */
  18 #include <sys/types.h>
  19 #include <sys/param.h>
  20 #include <sys/stat.h>
  21 #include <netatalk/endian.h>
  22 #include <atalk/afp.h>
  23 #include <atalk/compat.h>
  24 #include <atalk/util.h>
  25 #include <limits.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28
  29 #ifdef SHADOWPW
  30 #include <shadow.h>
  31 #endif /* SHADOWPW */
  32
  33 #include <pwd.h>
  34 #include <grp.h>
  35 #include <syslog.h>
  36
  37 #ifdef TRU64
  38 #include <netdb.h>
  39 #include <arpa/inet.h>
  40 #include <sia.h>
  41 #include <siad.h>
  42
  43 extern void afp_get_cmdline( int *ac, char ***av );
  44 #endif /* TRU64 */
  45
  46 #include "globals.h"
  47 #include "auth.h"
  48 #include "uam_auth.h"
  49 #include "switch.h"
  50 #include "status.h"
  51
  52 int     afp_version = 11;
  53 static int afp_version_index;
  54
  55 uid_t   uuid;
  56 #if defined( __svr4__ ) && !defined( NGROUPS )
  57 #define NGROUPS NGROUPS_MAX
  58 #endif /* __svr4__ NGROUPS */
  59 #if defined( sun ) && !defined( __svr4__ ) || defined( ultrix )
  60 int     groups[ NGROUPS ];
  61 #else /* sun __svr4__ ultrix */
  62 #if defined( __svr4__ ) && !defined( NGROUPS )
  63 #define NGROUPS NGROUPS_MAX
  64 #endif /* __svr4__ NGROUPS */
  65 gid_t   groups[ NGROUPS ];
  66 #endif /* sun ultrix */
  67 int     ngroups;
  68
  69 /*
  70  * These numbers are scattered throughout the code.
  71  */
  72 static struct afp_versions      afp_versions[] = {
  73             { "AFPVersion 1.1", 11 },
  74             { "AFPVersion 2.0", 20 },
  75             { "AFPVersion 2.1", 21 },
  76             { "AFP2.2", 22 }
  77         };
  78
  79 static struct uam_mod uam_modules = {NULL, NULL, &uam_modules, &uam_modules};
  80 static struct uam_obj uam_login = {"", "", 0, {{NULL}}, &uam_login,
  81                                       &uam_login};
  82 static struct uam_obj uam_changepw = {"", "", 0, {{NULL}}, &uam_changepw,
  83                                          &uam_changepw};
  84
  85 static struct uam_obj *afp_uam = NULL;
  86
  87
  88 void status_versions( data )
  89 char    *data;
  90 {
  91     char                *start = data;
  92     u_int16_t           status;
  93     int                 len, num, i;
  94
  95     memcpy(&status, start + AFPSTATUS_VERSOFF, sizeof(status));
  96     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ] );
  97     data += ntohs( status );
  98     *data++ = num;
  99     for ( i = 0; i < num; i++ ) {
 100         len = strlen( afp_versions[ i ].av_name );
 101         *data++ = len;
 102         memcpy( data, afp_versions[ i ].av_name , len );
 103         data += len;
 104     }
 105     status = htons( data - start );
 106     memcpy(start + AFPSTATUS_UAMSOFF, &status, sizeof(status));
 107 }
 108
 109 void status_uams(char *data, const char *authlist)
 110 {
 111     char                *start = data;
 112     u_int16_t           status;
 113     struct uam_obj      *uams;
 114     int                 len, num = 0;
 115
 116     memcpy(&status, start + AFPSTATUS_UAMSOFF, sizeof(status));
 117     uams = &uam_login;
 118     while ((uams = uams->uam_prev) != &uam_login) {
 119         if (strstr(authlist, uams->uam_path))
 120             num++;
 121     }
 122
 123     data += ntohs( status );
 124     *data++ = num;
 125     while ((uams = uams->uam_prev) != &uam_login) {
 126         if (strstr(authlist, uams->uam_path)) {
 127             syslog(LOG_INFO, "uam: \"%s\" available", uams->uam_name);
 128             len = strlen( uams->uam_name);
 129             *data++ = len;
 130             memcpy( data, uams->uam_name, len );
 131             data += len;
 132         }
 133     }
 134
 135     /* icon offset */
 136     status = htons(data - start);
 137     memcpy(start + AFPSTATUS_ICONOFF, &status, sizeof(status));
 138 }
 139
 140 /* handle errors by closing the connection. this is only needed
 141  * by the afp_* functions. */
 142 static int send_reply(const AFPObj *obj, const int err)
 143 {
 144     if ((err == AFP_OK) || (err == AFPERR_AUTHCONT))
 145         return err;
 146
 147     obj->reply(obj->handle, err);
 148     obj->exit(0);
 149
 150     return AFP_OK;
 151 }
 152
 153 static int login(AFPObj *obj, struct passwd *pwd, void (*logout)(void))
 154 {
 155 #ifdef ADMIN_GRP
 156     int admin = 0;
 157 #endif /* ADMIN_GRP */
 158
 159     /* UAM had syslog control; afpd needs to reassert itself */
 160     openlog( "afpd", LOG_NDELAY|LOG_PID, LOG_DAEMON);
 161
 162     if ( pwd->pw_uid == 0 ) {   /* don't allow root login */
 163         syslog( LOG_ERR, "login: root login denied!" );
 164         return AFPERR_NOTAUTH;
 165     }
 166
 167     syslog( LOG_INFO, "login %s (uid %d, gid %d) %s", pwd->pw_name,
 168             pwd->pw_uid, pwd->pw_gid, afp_versions[afp_version_index] );
 169
 170     if (obj->proto == AFPPROTO_ASP) {
 171         ASP asp = obj->handle;
 172         int addr_net = ntohs( asp->asp_sat.sat_addr.s_net );
 173         int addr_node  = asp->asp_sat.sat_addr.s_node;
 174
 175         if (obj->options.authprintdir) {
 176             if(addr_net && addr_node) { /* Do we have a valid Appletalk address? */
 177                 char nodename[256];
 178                 FILE *fp;
 179                 struct stat stat_buf;
 180
 181                 sprintf(nodename, "%s/net%d.%dnode%d", obj->options.authprintdir,
 182                         addr_net / 256, addr_net % 256, addr_node);
 183                 syslog (LOG_INFO, "registering %s (uid %d) on %u.%u as %s",
 184                         pwd->pw_name, pwd->pw_uid, addr_net, addr_node, nodename);
 185
 186                 if (stat(nodename, &stat_buf) == 0) { /* file exists */
 187                     if (S_ISREG(stat_buf.st_mode)) { /* normal file */
 188                         unlink(nodename);
 189                         fp = fopen(nodename, "w");
 190                         fprintf(fp, "%s\n", pwd->pw_name);
 191                         fclose(fp);
 192                         chown( nodename, pwd->pw_uid, -1 );
 193                     } else { /* somebody is messing with us */
 194                         syslog( LOG_ERR, "print authfile %s is not a normal file, it will not be modified", nodename );
 195                     }
 196                 } else { /* file 'nodename' does not exist */
 197                     fp = fopen(nodename, "w");
 198                     fprintf(fp, "%s\n", pwd->pw_name);
 199                     fclose(fp);
 200                     chown( nodename, pwd->pw_uid, -1 );
 201                 }
 202             } /* if (addr_net && addr_node ) */
 203         } /* if (options->authprintdir) */
 204     } /* if (obj->proto == AFPPROTO_ASP) */
 205
 206     if (initgroups( pwd->pw_name, pwd->pw_gid ) < 0) {
 207 #ifdef RUN_AS_USER
 208         syslog(LOG_INFO, "running with uid %d", geteuid());
 209 #else /* RUN_AS_USER */
 210         syslog(LOG_ERR, "login: %s", strerror(errno));
 211         return AFPERR_BADUAM;
 212 #endif /* RUN_AS_USER */
 213
 214     }
 215
 216     /* Basically if the user is in the admin group, we stay root */
 217
 218     if (( ngroups = getgroups( NGROUPS, groups )) < 0 ) {
 219         syslog( LOG_ERR, "login: getgroups: %s", strerror(errno) );
 220         return AFPERR_BADUAM;
 221     }
 222 #ifdef ADMIN_GRP
 223 #ifdef DEBUG
 224     syslog(LOG_INFO, "obj->options.admingid == %d", obj->options.admingid);
 225 #endif /* DEBUG */
 226     if (obj->options.admingid != 0) {
 227         int i;
 228         for (i = 0; i < ngroups; i++) {
 229             if (groups[i] == obj->options.admingid) admin = 1;
 230         }
 231     }
 232     if (admin) syslog( LOG_INFO, "admin login -- %s", pwd->pw_name );
 233     if (!admin)
 234 #endif /* DEBUG */
 235 #ifdef TRU64
 236     {
 237         struct DSI *dsi = obj->handle;
 238         struct hostent *hp;
 239         char *clientname;
 240         int argc;
 241         char **argv;
 242         char hostname[256];
 243
 244         afp_get_cmdline( &argc, &argv );
 245
 246         hp = gethostbyaddr( (char *) &dsi->client.sin_addr,
 247                             sizeof( struct in_addr ),
 248                             dsi->client.sin_family );
 249
 250         if( hp )
 251             clientname = hp->h_name;
 252         else
 253             clientname = inet_ntoa( dsi->client.sin_addr );
 254
 255         sprintf( hostname, "%s@%s", pwd->pw_name, clientname );
 256
 257         if( sia_become_user( NULL, argc, argv, hostname, pwd->pw_name,
 258                              NULL, FALSE, NULL, NULL,
 259                              SIA_BEU_REALLOGIN ) != SIASUCCESS )
 260             return AFPERR_BADUAM;
 261
 262         syslog( LOG_INFO, "session from %s (%s)", hostname,
 263                 inet_ntoa( dsi->client.sin_addr ) );
 264
 265         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 266             syslog( LOG_ERR, "login: %s", strerror(errno) );
 267             return AFPERR_BADUAM;
 268         }
 269     }
 270 #else /* TRU64 */
 271         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 272             syslog( LOG_ERR, "login: %s", strerror(errno) );
 273             return AFPERR_BADUAM;
 274         }
 275 #endif /* TRU64 */
 276
 277     /* There's probably a better way to do this, but for now, we just
 278     play root */
 279
 280 #ifdef ADMIN_GRP
 281     if (admin) uuid = 0;
 282     else
 283 #endif /* ADMIN_GRP */
 284         uuid = pwd->pw_uid;
 285
 286     afp_switch = postauth_switch;
 287     obj->logout = logout;
 288
 289     return( AFP_OK );
 290 }
 291
 292 int afp_login(obj, ibuf, ibuflen, rbuf, rbuflen )
 293 AFPObj      *obj;
 294 char    *ibuf, *rbuf;
 295 int             ibuflen, *rbuflen;
 296 {
 297     struct passwd *pwd = NULL;
 298     int         len, i, num;
 299
 300     *rbuflen = 0;
 301
 302
 303     if ( nologin & 1)
 304         return send_reply(obj, AFPERR_SHUTDOWN );
 305
 306     if (ibuflen <= 1)
 307         return send_reply(obj, AFPERR_BADVERS );
 308
 309     ibuf++;
 310     len = (unsigned char) *ibuf++;
 311
 312     ibuflen -= 2;
 313     if (!len || len > ibuflen)
 314         return send_reply(obj, AFPERR_BADVERS );
 315
 316     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ]);
 317     for ( i = 0; i < num; i++ ) {
 318         if ( strncmp( ibuf, afp_versions[ i ].av_name , len ) == 0 ) {
 319             afp_version = afp_versions[ i ].av_number;
 320             afp_version_index = i;
 321             break;
 322         }
 323     }
 324     if ( i == num )                             /* An inappropo version */
 325         return send_reply(obj, AFPERR_BADVERS );
 326     ibuf += len;
 327     ibuflen -= len;
 328
 329     if (ibuflen <= 1)
 330         return send_reply(obj, AFPERR_BADUAM);
 331
 332     len = (unsigned char) *ibuf++;
 333     ibuflen--;
 334
 335     if (!len || len > ibuflen)
 336         return send_reply(obj, AFPERR_BADUAM);
 337
 338     if ((afp_uam = auth_uamfind(UAM_SERVER_LOGIN, ibuf, len)) == NULL)
 339         return send_reply(obj, AFPERR_BADUAM);
 340     ibuf += len;
 341     ibuflen -= len;
 342
 343     i = afp_uam->u.uam_login.login(obj, &pwd, ibuf, ibuflen, rbuf, rbuflen);
 344     if (i || !pwd)
 345         return send_reply(obj, i);
 346
 347     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 348 }
 349
 350
 351 int afp_logincont(obj, ibuf, ibuflen, rbuf, rbuflen)
 352 AFPObj      *obj;
 353 char    *ibuf, *rbuf;
 354 int             ibuflen, *rbuflen;
 355 {
 356     struct passwd *pwd = NULL;
 357     int err;
 358
 359     if ( afp_uam == NULL || afp_uam->u.uam_login.logincont == NULL ) {
 360         *rbuflen = 0;
 361         return send_reply(obj, AFPERR_NOTAUTH );
 362     }
 363
 364     ibuf += 2;
 365     err = afp_uam->u.uam_login.logincont(obj, &pwd, ibuf, ibuflen,
 366                                          rbuf, rbuflen);
 367     if (err || !pwd)
 368         return send_reply(obj, err);
 369
 370     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 371 }
 372
 373
 374 int afp_logout(obj, ibuf, ibuflen, rbuf, rbuflen)
 375 AFPObj     *obj;
 376 char       *ibuf, *rbuf;
 377 int        ibuflen, *rbuflen;
 378 {
 379     syslog(LOG_INFO, "logout %s", obj->username);
 380     obj->exit(0);
 381     return AFP_OK;
 382 }
 383
 384
 385
 386 /* change password  --
 387  * NOTE: an FPLogin must already have completed successfully for this
 388  *       to work. this also does a little pre-processing before it hands
 389  *       it off to the uam.
 390  */
 391 int afp_changepw(obj, ibuf, ibuflen, rbuf, rbuflen )
 392 AFPObj      *obj;
 393 char    *ibuf, *rbuf;
 394 int             ibuflen, *rbuflen;
 395 {
 396     char username[MACFILELEN + 1], *start = ibuf;
 397     struct uam_obj *uam;
 398     struct passwd *pwd;
 399     int len;
 400
 401     *rbuflen = 0;
 402     ibuf += 2;
 403
 404     /* make sure we can deal w/ this uam */
 405     len = (unsigned char) *ibuf++;
 406     if ((uam = auth_uamfind(UAM_SERVER_CHANGEPW, ibuf, len)) == NULL)
 407         return AFPERR_BADUAM;
 408
 409     ibuf += len;
 410     if ((len + 1) & 1) /* pad byte */
 411         ibuf++;
 412
 413     len = (unsigned char) *ibuf++;
 414     if ( len > sizeof(username) - 1) {
 415         return AFPERR_PARAM;
 416     }
 417     memcpy(username, ibuf, len);
 418     username[ len ] = '\0';
 419     ibuf += len;
 420     if ((len + 1) & 1) /* pad byte */
 421         ibuf++;
 422
 423     syslog(LOG_INFO, "changing password for <%s>", username);
 424
 425     if (( pwd = uam_getname( username, sizeof(username))) == NULL )
 426         return AFPERR_PARAM;
 427
 428     /* send it off to the uam. we really don't use ibuflen right now. */
 429     ibuflen -= (ibuf - start);
 430     len = uam->u.uam_changepw(obj, username, pwd, ibuf, ibuflen,
 431                               rbuf, rbuflen);
 432     syslog(LOG_INFO, "password change %s.",
 433            (len == AFPERR_AUTHCONT) ? "continued" :
 434            (len ? "failed" : "succeeded"));
 435     return len;
 436 }
 437
 438
 439 /* FPGetUserInfo */
 440 int afp_getuserinfo(obj, ibuf, ibuflen, rbuf, rbuflen )
 441 AFPObj      *obj;
 442 char    *ibuf, *rbuf;
 443 int             ibuflen, *rbuflen;
 444 {
 445     u_int8_t  thisuser;
 446     u_int32_t id;
 447     u_int16_t bitmap;
 448
 449     *rbuflen = 0;
 450     ibuf++;
 451     thisuser = *ibuf++;
 452     ibuf += sizeof(id); /* userid is not used in AFP 2.0 */
 453     memcpy(&bitmap, ibuf, sizeof(bitmap));
 454     bitmap = ntohs(bitmap);
 455
 456     /* deal with error cases. we don't have to worry about
 457      * AFPERR_ACCESS or AFPERR_NOITEM as geteuid and getegid always
 458      * succeed. */
 459     if (!thisuser)
 460         return AFPERR_PARAM;
 461     if ((bitmap & USERIBIT_ALL) != bitmap)
 462         return AFPERR_BITMAP;
 463
 464     /* copy the bitmap back to reply buffer */
 465     memcpy(rbuf, ibuf, sizeof(bitmap));
 466     rbuf += sizeof(bitmap);
 467     *rbuflen = sizeof(bitmap);
 468
 469     /* copy the user/group info */
 470     if (bitmap & USERIBIT_USER) {
 471         id = htonl(geteuid());
 472         memcpy(rbuf, &id, sizeof(id));
 473         rbuf += sizeof(id);
 474         *rbuflen += sizeof(id);
 475     }
 476
 477     if (bitmap & USERIBIT_GROUP) {
 478         id = htonl(getegid());
 479         memcpy(rbuf, &id, sizeof(id));
 480         rbuf += sizeof(id);
 481         *rbuflen += sizeof(id);
 482     }
 483
 484     return AFP_OK;
 485 }
 486
 487 #define UAM_LIST(type) (((type) == UAM_SERVER_LOGIN) ? &uam_login : \
 488                         (((type) == UAM_SERVER_CHANGEPW) ? \
 489                          &uam_changepw : NULL))
 490
 491 /* just do a linked list search. this could be sped up with a hashed
 492  * list, but i doubt anyone's going to have enough uams to matter. */
 493 struct uam_obj *auth_uamfind(const int type, const char *name,
 494                                          const int len)
 495 {
 496     struct uam_obj *prev, *start;
 497
 498     if (!name || !(start = UAM_LIST(type)))
 499         return NULL;
 500
 501     prev = start;
 502     while ((prev = prev->uam_prev) != start)
 503         if (strndiacasecmp(prev->uam_name, name, len) == 0)
 504             return prev;
 505
 506     return NULL;
 507 }
 508
 509 int auth_register(const int type, struct uam_obj *uam)
 510 {
 511     struct uam_obj *start;
 512
 513     if (!uam || !uam->uam_name || (*uam->uam_name == '\0'))
 514         return -1;
 515
 516     if (!(start = UAM_LIST(type)))
 517         return 0; /* silently fail */
 518
 519     uam_attach(start, uam);
 520     return 0;
 521 }
 522
 523 /* load all of the modules */
 524 int auth_load(const char *path, const char *list)
 525 {
 526     char name[MAXPATHLEN + 1], buf[MAXPATHLEN + 1], *p;
 527     struct uam_mod *mod;
 528     struct stat st;
 529     int len;
 530
 531     if (!path || !list || (len = strlen(path)) > sizeof(name) - 2)
 532         return -1;
 533
 534     strncpy(buf, list, sizeof(buf));
 535     if ((p = strtok(buf, ",")) == NULL)
 536         return -1;
 537
 538     strcpy(name, path);
 539     if (name[len - 1] != '/') {
 540         strcat(name, "/");
 541         len++;
 542     }
 543
 544     while (p) {
 545         strncpy(name + len, p, sizeof(name) - len);
 546         syslog(LOG_DEBUG, "uam: loading (%s)", name);
 547         /*
 548         if ((stat(name, &st) == 0) && (mod = uam_load(name, p))) {
 549         */
 550         if (stat(name, &st) == 0) {
 551             if ((mod = uam_load(name, p))) {
 552                 uam_attach(&uam_modules, mod);
 553                 syslog(LOG_INFO, "uam: %s loaded", p);
 554             } else {
 555                 syslog(LOG_INFO, "uam: %s load failure",p);
 556             }
 557         } else {
 558             syslog(LOG_INFO, "uam: uam not found (status=%d)", stat(name, &st));
 559         }
 560         p = strtok(NULL, ",");
 561     }
 562
 563     return 0;
 564 }
 565
 566 /* get rid of all of the uams */
 567 void auth_unload()
 568 {
 569     struct uam_mod *mod, *prev, *start = &uam_modules;
 570
 571     prev = start->uam_prev;
 572     while ((mod = prev) != start) {
 573         prev = prev->uam_prev;
 574         uam_detach(mod);
 575         uam_unload(mod);
 576     }
 577 }