etc/afpd/auth.c

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