etc/afpd/auth.c

   1 /*
   2  * $Id: auth.c,v 1.24 2002-01-24 16:31:20 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 <atalk/logger.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             LOG(log_info, logtype_default, "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     set_processname("afpd");
 161     syslog_setup(log_debug, logtype_default, logoption_ndelay|logoption_pid, logfacility_daemon);
 162
 163     if ( pwd->pw_uid == 0 ) {   /* don't allow root login */
 164         LOG(log_error, logtype_default, "login: root login denied!" );
 165         return AFPERR_NOTAUTH;
 166     }
 167
 168     LOG(log_info, logtype_default, "login %s (uid %d, gid %d) %s", pwd->pw_name,
 169         pwd->pw_uid, pwd->pw_gid , afp_versions[afp_version_index]);
 170
 171     if (obj->proto == AFPPROTO_ASP) {
 172         ASP asp = obj->handle;
 173         int addr_net = ntohs( asp->asp_sat.sat_addr.s_net );
 174         int addr_node  = asp->asp_sat.sat_addr.s_node;
 175
 176         if (obj->options.authprintdir) {
 177             if(addr_net && addr_node) { /* Do we have a valid Appletalk address? */
 178                 char nodename[256];
 179                 FILE *fp;
 180                 struct stat stat_buf;
 181
 182                 sprintf(nodename, "%s/net%d.%dnode%d", obj->options.authprintdir,
 183                         addr_net / 256, addr_net % 256, addr_node);
 184                 LOG(log_info, logtype_default, "registering %s (uid %d) on %u.%u as %s",
 185                     pwd->pw_name, pwd->pw_uid, addr_net, addr_node, nodename);
 186
 187                 if (stat(nodename, &stat_buf) == 0) { /* file exists */
 188                     if (S_ISREG(stat_buf.st_mode)) { /* normal file */
 189                         unlink(nodename);
 190                         fp = fopen(nodename, "w");
 191                         fprintf(fp, "%s\n", pwd->pw_name);
 192                         fclose(fp);
 193                         chown( nodename, pwd->pw_uid, -1 );
 194                     } else { /* somebody is messing with us */
 195                         LOG(log_error, logtype_default, "print authfile %s is not a normal file, it will not be modified", nodename );
 196                     }
 197                 } else { /* file 'nodename' does not exist */
 198                     fp = fopen(nodename, "w");
 199                     fprintf(fp, "%s\n", pwd->pw_name);
 200                     fclose(fp);
 201                     chown( nodename, pwd->pw_uid, -1 );
 202                 }
 203             } /* if (addr_net && addr_node ) */
 204         } /* if (options->authprintdir) */
 205     } /* if (obj->proto == AFPPROTO_ASP) */
 206
 207     if (initgroups( pwd->pw_name, pwd->pw_gid ) < 0) {
 208 #ifdef RUN_AS_USER
 209         LOG(log_info, logtype_default, "running with uid %d", geteuid());
 210 #else /* RUN_AS_USER */
 211         LOG(log_error, logtype_default, "login: %s", strerror(errno));
 212         return AFPERR_BADUAM;
 213 #endif /* RUN_AS_USER */
 214
 215     }
 216
 217     /* Basically if the user is in the admin group, we stay root */
 218
 219     if (( ngroups = getgroups( NGROUPS, groups )) < 0 ) {
 220         LOG(log_error, logtype_default, "login: getgroups: %s", strerror(errno) );
 221         return AFPERR_BADUAM;
 222     }
 223 #ifdef ADMIN_GRP
 224 #ifdef DEBUG
 225     LOG(log_info, logtype_default, "obj->options.admingid == %d", obj->options.admingid);
 226 #endif /* DEBUG */
 227     if (obj->options.admingid != 0) {
 228         int i;
 229         for (i = 0; i < ngroups; i++) {
 230             if (groups[i] == obj->options.admingid) admin = 1;
 231         }
 232     }
 233     if (admin) LOG(log_info, logtype_default, "admin login -- %s", pwd->pw_name );
 234     if (!admin)
 235 #endif /* DEBUG */
 236 #ifdef TRU64
 237     {
 238         struct DSI *dsi = obj->handle;
 239         struct hostent *hp;
 240         char *clientname;
 241         int argc;
 242         char **argv;
 243         char hostname[256];
 244
 245         afp_get_cmdline( &argc, &argv );
 246
 247         hp = gethostbyaddr( (char *) &dsi->client.sin_addr,
 248                             sizeof( struct in_addr ),
 249                             dsi->client.sin_family );
 250
 251         if( hp )
 252             clientname = hp->h_name;
 253         else
 254             clientname = inet_ntoa( dsi->client.sin_addr );
 255
 256         sprintf( hostname, "%s@%s", pwd->pw_name, clientname );
 257
 258         if( sia_become_user( NULL, argc, argv, hostname, pwd->pw_name,
 259                              NULL, FALSE, NULL, NULL,
 260                              SIA_BEU_REALLOGIN ) != SIASUCCESS )
 261             return AFPERR_BADUAM;
 262
 263         LOG(log_info, logtype_default, "session from %s (%s)", hostname,
 264             inet_ntoa( dsi->client.sin_addr ) );
 265
 266         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 267             LOG(log_error, logtype_default, "login: %m" );
 268             return AFPERR_BADUAM;
 269         }
 270     }
 271 #else /* TRU64 */
 272         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 273             LOG(log_error, logtype_default, "login: %s", strerror(errno) );
 274             return AFPERR_BADUAM;
 275         }
 276 #endif /* TRU64 */
 277
 278     /* There's probably a better way to do this, but for now, we just
 279     play root */
 280
 281 #ifdef ADMIN_GRP
 282     if (admin) uuid = 0;
 283     else
 284 #endif /* ADMIN_GRP */
 285         uuid = pwd->pw_uid;
 286
 287     afp_switch = postauth_switch;
 288     obj->logout = logout;
 289
 290     return( AFP_OK );
 291 }
 292
 293 int afp_login(obj, ibuf, ibuflen, rbuf, rbuflen )
 294 AFPObj      *obj;
 295 char    *ibuf, *rbuf;
 296 int             ibuflen, *rbuflen;
 297 {
 298     struct passwd *pwd = NULL;
 299     int         len, i, num;
 300
 301     *rbuflen = 0;
 302
 303
 304     if ( nologin & 1)
 305         return send_reply(obj, AFPERR_SHUTDOWN );
 306
 307     if (ibuflen <= 1)
 308         return send_reply(obj, AFPERR_BADVERS );
 309
 310     ibuf++;
 311     len = (unsigned char) *ibuf++;
 312
 313     ibuflen -= 2;
 314     if (!len || len > ibuflen)
 315         return send_reply(obj, AFPERR_BADVERS );
 316
 317     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ]);
 318     for ( i = 0; i < num; i++ ) {
 319         if ( strncmp( ibuf, afp_versions[ i ].av_name , len ) == 0 ) {
 320             afp_version = afp_versions[ i ].av_number;
 321             afp_version_index = i;
 322             break;
 323         }
 324     }
 325     if ( i == num )                             /* An inappropo version */
 326         return send_reply(obj, AFPERR_BADVERS );
 327     ibuf += len;
 328     ibuflen -= len;
 329
 330     if (ibuflen <= 1)
 331         return send_reply(obj, AFPERR_BADUAM);
 332
 333     len = (unsigned char) *ibuf++;
 334     ibuflen--;
 335
 336     if (!len || len > ibuflen)
 337         return send_reply(obj, AFPERR_BADUAM);
 338
 339     if ((afp_uam = auth_uamfind(UAM_SERVER_LOGIN, ibuf, len)) == NULL)
 340         return send_reply(obj, AFPERR_BADUAM);
 341     ibuf += len;
 342     ibuflen -= len;
 343
 344     i = afp_uam->u.uam_login.login(obj, &pwd, ibuf, ibuflen, rbuf, rbuflen);
 345     if (i || !pwd)
 346         return send_reply(obj, i);
 347
 348     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 349 }
 350
 351
 352 int afp_logincont(obj, ibuf, ibuflen, rbuf, rbuflen)
 353 AFPObj      *obj;
 354 char    *ibuf, *rbuf;
 355 int             ibuflen, *rbuflen;
 356 {
 357     struct passwd *pwd = NULL;
 358     int err;
 359
 360     if ( afp_uam == NULL || afp_uam->u.uam_login.logincont == NULL ) {
 361         *rbuflen = 0;
 362         return send_reply(obj, AFPERR_NOTAUTH );
 363     }
 364
 365     ibuf += 2;
 366     err = afp_uam->u.uam_login.logincont(obj, &pwd, ibuf, ibuflen,
 367                                          rbuf, rbuflen);
 368     if (err || !pwd)
 369         return send_reply(obj, err);
 370
 371     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout));
 372 }
 373
 374
 375 int afp_logout(obj, ibuf, ibuflen, rbuf, rbuflen)
 376 AFPObj     *obj;
 377 char       *ibuf, *rbuf;
 378 int        ibuflen, *rbuflen;
 379 {
 380     LOG(log_info, logtype_default, "logout %s", obj->username);
 381     obj->exit(0);
 382     return AFP_OK;
 383 }
 384
 385
 386
 387 /* change password  --
 388  * NOTE: an FPLogin must already have completed successfully for this
 389  *       to work. this also does a little pre-processing before it hands
 390  *       it off to the uam.
 391  */
 392 int afp_changepw(obj, ibuf, ibuflen, rbuf, rbuflen )
 393 AFPObj      *obj;
 394 char    *ibuf, *rbuf;
 395 int             ibuflen, *rbuflen;
 396 {
 397     char username[MACFILELEN + 1], *start = ibuf;
 398     struct uam_obj *uam;
 399     struct passwd *pwd;
 400     int len;
 401
 402     *rbuflen = 0;
 403     ibuf += 2;
 404
 405     /* make sure we can deal w/ this uam */
 406     len = (unsigned char) *ibuf++;
 407     if ((uam = auth_uamfind(UAM_SERVER_CHANGEPW, ibuf, len)) == NULL)
 408         return AFPERR_BADUAM;
 409
 410     ibuf += len;
 411     if ((len + 1) & 1) /* pad byte */
 412         ibuf++;
 413
 414     len = (unsigned char) *ibuf++;
 415     if ( len > sizeof(username) - 1) {
 416         return AFPERR_PARAM;
 417     }
 418     memcpy(username, ibuf, len);
 419     username[ len ] = '\0';
 420     ibuf += len;
 421     if ((len + 1) & 1) /* pad byte */
 422         ibuf++;
 423
 424     LOG(log_info, logtype_default, "changing password for <%s>", username);
 425
 426     if (( pwd = uam_getname( username, sizeof(username))) == NULL )
 427         return AFPERR_PARAM;
 428
 429     /* send it off to the uam. we really don't use ibuflen right now. */
 430     ibuflen -= (ibuf - start);
 431     len = uam->u.uam_changepw(obj, username, pwd, ibuf, ibuflen,
 432                               rbuf, rbuflen);
 433     LOG(log_info, logtype_default, "password change %s.",
 434         (len == AFPERR_AUTHCONT) ? "continued" :
 435         (len ? "failed" : "succeeded"));
 436     return len;
 437 }
 438
 439
 440 /* FPGetUserInfo */
 441 int afp_getuserinfo(obj, ibuf, ibuflen, rbuf, rbuflen )
 442 AFPObj      *obj;
 443 char    *ibuf, *rbuf;
 444 int             ibuflen, *rbuflen;
 445 {
 446     u_int8_t  thisuser;
 447     u_int32_t id;
 448     u_int16_t bitmap;
 449
 450     *rbuflen = 0;
 451     ibuf++;
 452     thisuser = *ibuf++;
 453     ibuf += sizeof(id); /* userid is not used in AFP 2.0 */
 454     memcpy(&bitmap, ibuf, sizeof(bitmap));
 455     bitmap = ntohs(bitmap);
 456
 457     /* deal with error cases. we don't have to worry about
 458      * AFPERR_ACCESS or AFPERR_NOITEM as geteuid and getegid always
 459      * succeed. */
 460     if (!thisuser)
 461         return AFPERR_PARAM;
 462     if ((bitmap & USERIBIT_ALL) != bitmap)
 463         return AFPERR_BITMAP;
 464
 465     /* copy the bitmap back to reply buffer */
 466     memcpy(rbuf, ibuf, sizeof(bitmap));
 467     rbuf += sizeof(bitmap);
 468     *rbuflen = sizeof(bitmap);
 469
 470     /* copy the user/group info */
 471     if (bitmap & USERIBIT_USER) {
 472         id = htonl(geteuid());
 473         memcpy(rbuf, &id, sizeof(id));
 474         rbuf += sizeof(id);
 475         *rbuflen += sizeof(id);
 476     }
 477
 478     if (bitmap & USERIBIT_GROUP) {
 479         id = htonl(getegid());
 480         memcpy(rbuf, &id, sizeof(id));
 481         rbuf += sizeof(id);
 482         *rbuflen += sizeof(id);
 483     }
 484
 485     return AFP_OK;
 486 }
 487
 488 #define UAM_LIST(type) (((type) == UAM_SERVER_LOGIN) ? &uam_login : \
 489                         (((type) == UAM_SERVER_CHANGEPW) ? \
 490                          &uam_changepw : NULL))
 491
 492 /* just do a linked list search. this could be sped up with a hashed
 493  * list, but i doubt anyone's going to have enough uams to matter. */
 494 struct uam_obj *auth_uamfind(const int type, const char *name,
 495                                          const int len)
 496 {
 497     struct uam_obj *prev, *start;
 498
 499     if (!name || !(start = UAM_LIST(type)))
 500         return NULL;
 501
 502     prev = start;
 503     while ((prev = prev->uam_prev) != start)
 504         if (strndiacasecmp(prev->uam_name, name, len) == 0)
 505             return prev;
 506
 507     return NULL;
 508 }
 509
 510 int auth_register(const int type, struct uam_obj *uam)
 511 {
 512     struct uam_obj *start;
 513
 514     if (!uam || !uam->uam_name || (*uam->uam_name == '\0'))
 515         return -1;
 516
 517     if (!(start = UAM_LIST(type)))
 518         return 0; /* silently fail */
 519
 520     uam_attach(start, uam);
 521     return 0;
 522 }
 523
 524 /* load all of the modules */
 525 int auth_load(const char *path, const char *list)
 526 {
 527     char name[MAXPATHLEN + 1], buf[MAXPATHLEN + 1], *p;
 528     struct uam_mod *mod;
 529     struct stat st;
 530     int len;
 531
 532     if (!path || !list || (len = strlen(path)) > sizeof(name) - 2)
 533         return -1;
 534
 535     strncpy(buf, list, sizeof(buf));
 536     if ((p = strtok(buf, ",")) == NULL)
 537         return -1;
 538
 539     strcpy(name, path);
 540     if (name[len - 1] != '/') {
 541         strcat(name, "/");
 542         len++;
 543     }
 544
 545     while (p) {
 546         strncpy(name + len, p, sizeof(name) - len);
 547         LOG(log_debug, logtype_default, "uam: loading (%s)", name);
 548         /*
 549         if ((stat(name, &st) == 0) && (mod = uam_load(name, p))) {
 550         */
 551         if (stat(name, &st) == 0) {
 552             if ((mod = uam_load(name, p))) {
 553                 uam_attach(&uam_modules, mod);
 554                 LOG(log_info, logtype_default, "uam: %s loaded", p);
 555             } else {
 556                 LOG(log_info, logtype_default, "uam: %s load failure",p);
 557             }
 558         } else {
 559             LOG(log_info, logtype_default, "uam: uam not found (status=%d)", stat(name, &st));
 560         }
 561         p = strtok(NULL, ",");
 562     }
 563
 564     return 0;
 565 }
 566
 567 /* get rid of all of the uams */
 568 void auth_unload()
 569 {
 570     struct uam_mod *mod, *prev, *start = &uam_modules;
 571
 572     prev = start->uam_prev;
 573     while ((mod = prev) != start) {
 574         prev = prev->uam_prev;
 575         uam_detach(mod);
 576         uam_unload(mod);
 577     }
 578 }