lib/uid_wrapper/uid_wrapper.c

   1 /*
   2  * Copyright (c) 2009      Andrew Tridgell
   3  * Copyright (c) 2011-2013 Andreas Schneider <asn@samba.org>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include <errno.h>
  22 #include <stdarg.h>
  23 #include <stdbool.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29 #include <grp.h>
  30 #ifdef HAVE_SYS_SYSCALL_H
  31 #include <sys/syscall.h>
  32 #endif
  33 #ifdef HAVE_SYSCALL_H
  34 #include <syscall.h>
  35 #endif
  36 #include <dlfcn.h>
  37
  38 #include <pthread.h>
  39
  40 #ifdef HAVE_GCC_THREAD_LOCAL_STORAGE
  41 # define UWRAP_THREAD __thread
  42 #else
  43 # define UWRAP_THREAD
  44 #endif
  45
  46 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
  47 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
  48 #else
  49 #define DESTRUCTOR_ATTRIBUTE
  50 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
  51
  52 /* GCC have printf type attribute check. */
  53 #ifdef HAVE_FUNCTION_ATTRIBUTE_FORMAT
  54 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
  55 #else
  56 #define PRINTF_ATTRIBUTE(a,b)
  57 #endif /* HAVE_FUNCTION_ATTRIBUTE_FORMAT */
  58
  59 #define UWRAP_DLIST_ADD(list,item) do { \
  60         if (!(list)) { \
  61                 (item)->prev    = NULL; \
  62                 (item)->next    = NULL; \
  63                 (list)          = (item); \
  64         } else { \
  65                 (item)->prev    = NULL; \
  66                 (item)->next    = (list); \
  67                 (list)->prev    = (item); \
  68                 (list)          = (item); \
  69         } \
  70 } while (0)
  71
  72 #define UWRAP_DLIST_REMOVE(list,item) do { \
  73         if ((list) == (item)) { \
  74                 (list)          = (item)->next; \
  75                 if (list) { \
  76                         (list)->prev    = NULL; \
  77                 } \
  78         } else { \
  79                 if ((item)->prev) { \
  80                         (item)->prev->next      = (item)->next; \
  81                 } \
  82                 if ((item)->next) { \
  83                         (item)->next->prev      = (item)->prev; \
  84                 } \
  85         } \
  86         (item)->prev    = NULL; \
  87         (item)->next    = NULL; \
  88 } while (0)
  89
  90 #ifndef SAFE_FREE
  91 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
  92 #endif
  93
  94 /*****************
  95  * LOGGING
  96  *****************/
  97
  98 enum uwrap_dbglvl_e {
  99         UWRAP_LOG_ERROR = 0,
 100         UWRAP_LOG_WARN,
 101         UWRAP_LOG_DEBUG,
 102         UWRAP_LOG_TRACE
 103 };
 104
 105 #ifdef NDEBUG
 106 # define UWRAP_LOG(...)
 107 #else /* NDEBUG */
 108 static void uwrap_log(enum uwrap_dbglvl_e dbglvl, const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
 109 # define UWRAP_LOG(dbglvl, ...) uwrap_log((dbglvl), __VA_ARGS__)
 110
 111 static void uwrap_log(enum uwrap_dbglvl_e dbglvl, const char *format, ...)
 112 {
 113         char buffer[1024];
 114         va_list va;
 115         const char *d;
 116         unsigned int lvl = 0;
 117
 118         d = getenv("UID_WRAPPER_DEBUGLEVEL");
 119         if (d != NULL) {
 120                 lvl = atoi(d);
 121         }
 122
 123         va_start(va, format);
 124         vsnprintf(buffer, sizeof(buffer), format, va);
 125         va_end(va);
 126
 127         if (lvl >= dbglvl) {
 128                 switch (dbglvl) {
 129                         case UWRAP_LOG_ERROR:
 130                                 fprintf(stderr,
 131                                         "UWRAP_ERROR(%d): %s\n",
 132                                         (int)getpid(), buffer);
 133                                 break;
 134                         case UWRAP_LOG_WARN:
 135                                 fprintf(stderr,
 136                                         "UWRAP_WARN(%d): %s\n",
 137                                         (int)getpid(), buffer);
 138                                 break;
 139                         case UWRAP_LOG_DEBUG:
 140                                 fprintf(stderr,
 141                                         "UWRAP_DEBUG(%d): %s\n",
 142                                         (int)getpid(), buffer);
 143                                 break;
 144                         case UWRAP_LOG_TRACE:
 145                                 fprintf(stderr,
 146                                         "UWRAP_TRACE(%d): %s\n",
 147                                         (int)getpid(), buffer);
 148                                 break;
 149                 }
 150         }
 151 }
 152 #endif /* NDEBUG */
 153
 154 /*****************
 155  * LIBC
 156  *****************/
 157
 158 #define LIBC_NAME "libc.so"
 159
 160 struct uwrap_libc_fns {
 161         int (*_libc_setuid)(uid_t uid);
 162         uid_t (*_libc_getuid)(void);
 163
 164 #ifdef HAVE_SETEUID
 165         int (*_libc_seteuid)(uid_t euid);
 166 #endif
 167 #ifdef HAVE_SETREUID
 168         int (*_libc_setreuid)(uid_t ruid, uid_t euid);
 169 #endif
 170 #ifdef HAVE_SETRESUID
 171         int (*_libc_setresuid)(uid_t ruid, uid_t euid, uid_t suid);
 172 #endif
 173         uid_t (*_libc_geteuid)(void);
 174
 175         int (*_libc_setgid)(gid_t gid);
 176         gid_t (*_libc_getgid)(void);
 177 #ifdef HAVE_SETEGID
 178         int (*_libc_setegid)(uid_t egid);
 179 #endif
 180 #ifdef HAVE_SETREGID
 181         int (*_libc_setregid)(uid_t rgid, uid_t egid);
 182 #endif
 183 #ifdef HAVE_SETRESGID
 184         int (*_libc_setresgid)(uid_t rgid, uid_t egid, uid_t sgid);
 185 #endif
 186         gid_t (*_libc_getegid)(void);
 187         int (*_libc_getgroups)(int size, gid_t list[]);
 188         int (*_libc_setgroups)(size_t size, const gid_t *list);
 189 #ifdef HAVE_SYSCALL
 190         long int (*_libc_syscall)(long int sysno, ...);
 191 #endif
 192 };
 193
 194 /*
 195  * We keep the virtualised euid/egid/groups information here
 196  */
 197 struct uwrap_thread {
 198         pthread_t tid;
 199         bool dead;
 200
 201         uid_t ruid;
 202         uid_t euid;
 203         uid_t suid;
 204
 205         gid_t rgid;
 206         gid_t egid;
 207         gid_t sgid;
 208
 209         gid_t *groups;
 210         int ngroups;
 211
 212         struct uwrap_thread *next;
 213         struct uwrap_thread *prev;
 214 };
 215
 216 struct uwrap {
 217         struct {
 218                 void *handle;
 219                 struct uwrap_libc_fns fns;
 220         } libc;
 221
 222         bool initialised;
 223         bool enabled;
 224
 225         uid_t myuid;
 226         uid_t mygid;
 227
 228         struct uwrap_thread *ids;
 229 };
 230
 231 static struct uwrap uwrap;
 232
 233 /* Shortcut to the list item */
 234 static UWRAP_THREAD struct uwrap_thread *uwrap_tls_id;
 235
 236 /* The mutex or accessing the id */
 237 static pthread_mutex_t uwrap_id_mutex = PTHREAD_MUTEX_INITIALIZER;
 238
 239 /*********************************************************
 240  * UWRAP PROTOTYPES
 241  *********************************************************/
 242
 243 bool uid_wrapper_enabled(void);
 244 void uwrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
 245
 246 /*********************************************************
 247  * UWRAP LIBC LOADER FUNCTIONS
 248  *********************************************************/
 249
 250 enum uwrap_lib {
 251     UWRAP_LIBC,
 252     UWRAP_LIBNSL,
 253     UWRAP_LIBSOCKET,
 254 };
 255
 256 static void *uwrap_load_lib_handle(enum uwrap_lib lib)
 257 {
 258         int flags = RTLD_LAZY;
 259         void *handle = NULL;
 260         int i;
 261
 262 #ifdef RTLD_DEEPBIND
 263         flags |= RTLD_DEEPBIND;
 264 #endif
 265
 266         switch (lib) {
 267         case UWRAP_LIBNSL:
 268                 /* FALL TROUGH */
 269         case UWRAP_LIBSOCKET:
 270                 /* FALL TROUGH */
 271         case UWRAP_LIBC:
 272                 handle = uwrap.libc.handle;
 273                 if (handle == NULL) {
 274                         for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
 275                                 char soname[256] = {0};
 276
 277                                 snprintf(soname, sizeof(soname), "libc.so.%d", i);
 278                                 handle = dlopen(soname, flags);
 279                         }
 280
 281                         uwrap.libc.handle = handle;
 282                 }
 283                 break;
 284         }
 285
 286         if (handle == NULL) {
 287 #ifdef RTLD_NEXT
 288                 handle = uwrap.libc.handle = RTLD_NEXT;
 289 #else
 290                 fprintf(stderr,
 291                         "Failed to dlopen library: %s\n",
 292                         dlerror());
 293                 exit(-1);
 294 #endif
 295         }
 296
 297         return handle;
 298 }
 299
 300 static void *_uwrap_load_lib_function(enum uwrap_lib lib, const char *fn_name)
 301 {
 302         void *handle;
 303         void *func;
 304
 305         handle = uwrap_load_lib_handle(lib);
 306
 307         func = dlsym(handle, fn_name);
 308         if (func == NULL) {
 309                 fprintf(stderr,
 310                         "Failed to find %s: %s\n",
 311                         fn_name, dlerror());
 312                 exit(-1);
 313         }
 314
 315         return func;
 316 }
 317
 318 #define uwrap_load_lib_function(lib, fn_name) \
 319         if (uwrap.libc.fns._libc_##fn_name == NULL) { \
 320                 *(void **) (&uwrap.libc.fns._libc_##fn_name) = \
 321                         _uwrap_load_lib_function(lib, #fn_name); \
 322         }
 323
 324 /*
 325  * IMPORTANT
 326  *
 327  * Functions expeciall from libc need to be loaded individually, you can't load
 328  * all at once or gdb will segfault at startup. The same applies to valgrind and
 329  * has probably something todo with with the linker.
 330  * So we need load each function at the point it is called the first time.
 331  */
 332 static int libc_setuid(uid_t uid)
 333 {
 334         uwrap_load_lib_function(UWRAP_LIBC, setuid);
 335
 336         return uwrap.libc.fns._libc_setuid(uid);
 337 }
 338
 339 static uid_t libc_getuid(void)
 340 {
 341         uwrap_load_lib_function(UWRAP_LIBC, getuid);
 342
 343         return uwrap.libc.fns._libc_getuid();
 344 }
 345
 346 #ifdef HAVE_SETEUID
 347 static int libc_seteuid(uid_t euid)
 348 {
 349         uwrap_load_lib_function(UWRAP_LIBC, seteuid);
 350
 351         return uwrap.libc.fns._libc_seteuid(euid);
 352 }
 353 #endif
 354
 355 #ifdef HAVE_SETREUID
 356 static int libc_setreuid(uid_t ruid, uid_t euid)
 357 {
 358         uwrap_load_lib_function(UWRAP_LIBC, setreuid);
 359
 360         return uwrap.libc.fns._libc_setreuid(ruid, euid);
 361 }
 362 #endif
 363
 364 #ifdef HAVE_SETRESUID
 365 static int libc_setresuid(uid_t ruid, uid_t euid, uid_t suid)
 366 {
 367         uwrap_load_lib_function(UWRAP_LIBC, setresuid);
 368
 369         return uwrap.libc.fns._libc_setresuid(ruid, euid, suid);
 370 }
 371 #endif
 372
 373 static uid_t libc_geteuid(void)
 374 {
 375         uwrap_load_lib_function(UWRAP_LIBC, geteuid);
 376
 377         return uwrap.libc.fns._libc_geteuid();
 378 }
 379
 380 static int libc_setgid(gid_t gid)
 381 {
 382         uwrap_load_lib_function(UWRAP_LIBC, setgid);
 383
 384         return uwrap.libc.fns._libc_setgid(gid);
 385 }
 386
 387 static gid_t libc_getgid(void)
 388 {
 389         uwrap_load_lib_function(UWRAP_LIBC, getgid);
 390
 391         return uwrap.libc.fns._libc_getgid();
 392 }
 393
 394 #ifdef HAVE_SETEGID
 395 static int libc_setegid(gid_t egid)
 396 {
 397         uwrap_load_lib_function(UWRAP_LIBC, setegid);
 398
 399         return uwrap.libc.fns._libc_setegid(egid);
 400 }
 401 #endif
 402
 403 #ifdef HAVE_SETREGID
 404 static int libc_setregid(gid_t rgid, gid_t egid)
 405 {
 406         uwrap_load_lib_function(UWRAP_LIBC, setregid);
 407
 408         return uwrap.libc.fns._libc_setregid(rgid, egid);
 409 }
 410 #endif
 411
 412 #ifdef HAVE_SETRESGID
 413 static int libc_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 414 {
 415         uwrap_load_lib_function(UWRAP_LIBC, setresgid);
 416
 417         return uwrap.libc.fns._libc_setresgid(rgid, egid, sgid);
 418 }
 419 #endif
 420
 421 static gid_t libc_getegid(void)
 422 {
 423         uwrap_load_lib_function(UWRAP_LIBC, getegid);
 424
 425         return uwrap.libc.fns._libc_getegid();
 426 }
 427
 428 static int libc_getgroups(int size, gid_t list[])
 429 {
 430         uwrap_load_lib_function(UWRAP_LIBC, getgroups);
 431
 432         return uwrap.libc.fns._libc_getgroups(size, list);
 433 }
 434
 435 static int libc_setgroups(size_t size, const gid_t *list)
 436 {
 437         uwrap_load_lib_function(UWRAP_LIBC, setgroups);
 438
 439         return uwrap.libc.fns._libc_setgroups(size, list);
 440 }
 441
 442 #ifdef HAVE_SYSCALL
 443 static long int libc_vsyscall(long int sysno, va_list va)
 444 {
 445         long int args[8];
 446         long int rc;
 447         int i;
 448
 449         uwrap_load_lib_function(UWRAP_LIBC, syscall);
 450
 451         for (i = 0; i < 8; i++) {
 452                 args[i] = va_arg(va, long int);
 453         }
 454
 455         rc = uwrap.libc.fns._libc_syscall(sysno,
 456                                           args[0],
 457                                           args[1],
 458                                           args[2],
 459                                           args[3],
 460                                           args[4],
 461                                           args[5],
 462                                           args[6],
 463                                           args[7]);
 464
 465         return rc;
 466 }
 467 #endif
 468
 469 /*********************************************************
 470  * UWRAP ID HANDLING
 471  *********************************************************/
 472
 473 static struct uwrap_thread *find_uwrap_id(pthread_t tid)
 474 {
 475         struct uwrap_thread *id;
 476
 477         for (id = uwrap.ids; id; id = id->next) {
 478                 if (pthread_equal(id->tid, tid)) {
 479                         return id;
 480                 }
 481         }
 482
 483         return NULL;
 484 }
 485
 486 static int uwrap_new_id(pthread_t tid, bool do_alloc)
 487 {
 488         struct uwrap_thread *id = uwrap_tls_id;
 489
 490         if (do_alloc) {
 491                 id = malloc(sizeof(struct uwrap_thread));
 492                 if (id == NULL) {
 493                         errno = ENOMEM;
 494                         return -1;
 495                 }
 496
 497                 id->groups = malloc(sizeof(gid_t) * 1);
 498                 if (id->groups == NULL) {
 499                         SAFE_FREE(id);
 500                         errno = ENOMEM;
 501                         return -1;
 502                 }
 503
 504                 UWRAP_DLIST_ADD(uwrap.ids, id);
 505                 uwrap_tls_id = id;
 506         }
 507
 508         id->tid = tid;
 509         id->dead = false;
 510
 511         id->ruid = id->euid = id->suid = uwrap.myuid;
 512         id->rgid = id->egid = id->sgid = uwrap.mygid;
 513
 514         id->ngroups = 1;
 515         id->groups[0] = uwrap.mygid;
 516
 517         return 0;
 518 }
 519
 520 static void uwrap_thread_prepare(void)
 521 {
 522         pthread_mutex_lock(&uwrap_id_mutex);
 523
 524         /*
 525          * What happens if another atfork prepare functions calls a uwrap
 526          * function? So disable it in case another atfork prepare function
 527          * calls a (s)uid function.
 528          */
 529         uwrap.enabled = false;
 530 }
 531
 532 static void uwrap_thread_parent(void)
 533 {
 534         uwrap.enabled = true;
 535
 536         pthread_mutex_unlock(&uwrap_id_mutex);
 537 }
 538
 539 static void uwrap_thread_child(void)
 540 {
 541         uwrap.enabled = true;
 542
 543         pthread_mutex_unlock(&uwrap_id_mutex);
 544 }
 545
 546 static void uwrap_init(void)
 547 {
 548         const char *env = getenv("UID_WRAPPER");
 549         pthread_t tid = pthread_self();
 550
 551
 552
 553         if (uwrap.initialised) {
 554                 struct uwrap_thread *id = uwrap_tls_id;
 555                 int rc;
 556
 557                 if (id != NULL) {
 558                         return;
 559                 }
 560
 561                 pthread_mutex_lock(&uwrap_id_mutex);
 562                 id = find_uwrap_id(tid);
 563                 if (id == NULL) {
 564                         rc = uwrap_new_id(tid, true);
 565                         if (rc < 0) {
 566                                 exit(-1);
 567                         }
 568                 } else {
 569                         /* We reuse an old thread id */
 570                         uwrap_tls_id = id;
 571
 572                         uwrap_new_id(tid, false);
 573                 }
 574                 pthread_mutex_unlock(&uwrap_id_mutex);
 575
 576                 return;
 577         }
 578
 579         /*
 580          * If we hold a lock and the application forks, then the child
 581          * is not able to unlock the mutex and we are in a deadlock.
 582          * This should prevent such deadlocks.
 583          */
 584         pthread_atfork(&uwrap_thread_prepare,
 585                        &uwrap_thread_parent,
 586                        &uwrap_thread_child);
 587
 588         pthread_mutex_lock(&uwrap_id_mutex);
 589
 590         uwrap.initialised = true;
 591         uwrap.enabled = false;
 592
 593         if (env != NULL && env[0] == '1') {
 594                 const char *root = getenv("UID_WRAPPER_ROOT");
 595                 int rc;
 596
 597                 /* put us in one group */
 598                 if (root != NULL && root[0] == '1') {
 599                         uwrap.myuid = 0;
 600                         uwrap.mygid = 0;
 601                 } else {
 602                         uwrap.myuid = libc_geteuid();
 603                         uwrap.mygid = libc_getegid();
 604                 }
 605
 606                 rc = uwrap_new_id(tid, true);
 607                 if (rc < 0) {
 608                         exit(-1);
 609                 }
 610
 611                 uwrap.enabled = true;
 612         }
 613
 614         pthread_mutex_unlock(&uwrap_id_mutex);
 615 }
 616
 617 bool uid_wrapper_enabled(void)
 618 {
 619         uwrap_init();
 620
 621         return uwrap.enabled ? true : false;
 622 }
 623
 624 static int uwrap_setresuid_thread(uid_t ruid, uid_t euid, uid_t suid)
 625 {
 626         struct uwrap_thread *id = uwrap_tls_id;
 627
 628         if (ruid == (uid_t)-1 && euid == (uid_t)-1 && suid == (uid_t)-1) {
 629                 errno = EINVAL;
 630                 return -1;
 631         }
 632
 633         pthread_mutex_lock(&uwrap_id_mutex);
 634         if (ruid != (uid_t)-1) {
 635                 id->ruid = ruid;
 636         }
 637
 638         if (euid != (uid_t)-1) {
 639                 id->euid = euid;
 640         }
 641
 642         if (suid != (uid_t)-1) {
 643                 id->suid = suid;
 644         }
 645         pthread_mutex_unlock(&uwrap_id_mutex);
 646
 647         return 0;
 648 }
 649
 650 static int uwrap_setresuid(uid_t ruid, uid_t euid, uid_t suid)
 651 {
 652         struct uwrap_thread *id;
 653
 654         if (ruid == (uid_t)-1 && euid == (uid_t)-1 && suid == (uid_t)-1) {
 655                 errno = EINVAL;
 656                 return -1;
 657         }
 658
 659         pthread_mutex_lock(&uwrap_id_mutex);
 660         for (id = uwrap.ids; id; id = id->next) {
 661                 if (id->dead) {
 662                         continue;
 663                 }
 664
 665                 if (ruid != (uid_t)-1) {
 666                         id->ruid = ruid;
 667                 }
 668
 669                 if (euid != (uid_t)-1) {
 670                         id->euid = euid;
 671                 }
 672
 673                 if (suid != (uid_t)-1) {
 674                         id->suid = suid;
 675                 }
 676         }
 677         pthread_mutex_unlock(&uwrap_id_mutex);
 678
 679         return 0;
 680 }
 681
 682 /*
 683  * SETUID
 684  */
 685 int setuid(uid_t uid)
 686 {
 687         if (!uid_wrapper_enabled()) {
 688                 return libc_setuid(uid);
 689         }
 690
 691         return uwrap_setresuid(uid, -1, -1);
 692 }
 693
 694 #ifdef HAVE_SETEUID
 695 int seteuid(uid_t euid)
 696 {
 697         if (euid == (uid_t)-1) {
 698                 errno = EINVAL;
 699                 return -1;
 700         }
 701
 702         if (!uid_wrapper_enabled()) {
 703                 return libc_seteuid(euid);
 704         }
 705
 706         return uwrap_setresuid(-1, euid, -1);
 707 }
 708 #endif
 709
 710 #ifdef HAVE_SETREUID
 711 int setreuid(uid_t ruid, uid_t euid)
 712 {
 713         if (ruid == (uid_t)-1 && euid == (uid_t)-1) {
 714                 errno = EINVAL;
 715                 return -1;
 716         }
 717
 718         if (!uid_wrapper_enabled()) {
 719                 return libc_setreuid(ruid, euid);
 720         }
 721
 722         return uwrap_setresuid(ruid, euid, -1);
 723 }
 724 #endif
 725
 726 #ifdef HAVE_SETRESUID
 727 int setresuid(uid_t ruid, uid_t euid, uid_t suid)
 728 {
 729         if (!uid_wrapper_enabled()) {
 730                 return libc_setresuid(ruid, euid, suid);
 731         }
 732
 733         return uwrap_setresuid(ruid, euid, suid);
 734 }
 735 #endif
 736
 737 /*
 738  * GETUID
 739  */
 740 static uid_t uwrap_getuid(void)
 741 {
 742         struct uwrap_thread *id = uwrap_tls_id;
 743         uid_t uid;
 744
 745         pthread_mutex_lock(&uwrap_id_mutex);
 746         uid = id->ruid;
 747         pthread_mutex_unlock(&uwrap_id_mutex);
 748
 749         return uid;
 750 }
 751
 752 uid_t getuid(void)
 753 {
 754         if (!uid_wrapper_enabled()) {
 755                 return libc_getuid();
 756         }
 757
 758         return uwrap_getuid();
 759 }
 760
 761 /*
 762  * GETEUID
 763  */
 764 static uid_t uwrap_geteuid(void)
 765 {
 766         const char *env = getenv("UID_WRAPPER_MYUID");
 767         struct uwrap_thread *id = uwrap_tls_id;
 768         uid_t uid;
 769
 770         pthread_mutex_lock(&uwrap_id_mutex);
 771         uid = id->euid;
 772         pthread_mutex_unlock(&uwrap_id_mutex);
 773
 774         /* Disable root and return myuid */
 775         if (env != NULL && env[0] == '1') {
 776                 uid = uwrap.myuid;
 777         }
 778
 779         return uid;
 780 }
 781
 782 uid_t geteuid(void)
 783 {
 784         if (!uid_wrapper_enabled()) {
 785                 return libc_geteuid();
 786         }
 787
 788         return uwrap_geteuid();
 789 }
 790
 791 static int uwrap_setresgid_thread(gid_t rgid, gid_t egid, gid_t sgid)
 792 {
 793         struct uwrap_thread *id = uwrap_tls_id;
 794
 795         if (rgid == (gid_t)-1 && egid == (gid_t)-1 && sgid == (gid_t)-1) {
 796                 errno = EINVAL;
 797                 return -1;
 798         }
 799
 800         pthread_mutex_lock(&uwrap_id_mutex);
 801         if (rgid != (gid_t)-1) {
 802                 id->rgid = rgid;
 803         }
 804
 805         if (egid != (gid_t)-1) {
 806                 id->egid = egid;
 807         }
 808
 809         if (sgid != (gid_t)-1) {
 810                 id->sgid = sgid;
 811         }
 812         pthread_mutex_unlock(&uwrap_id_mutex);
 813
 814         return 0;
 815 }
 816
 817 static int uwrap_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 818 {
 819         struct uwrap_thread *id;
 820
 821         if (rgid == (gid_t)-1 && egid == (gid_t)-1 && sgid == (gid_t)-1) {
 822                 errno = EINVAL;
 823                 return -1;
 824         }
 825
 826         pthread_mutex_lock(&uwrap_id_mutex);
 827         for (id = uwrap.ids; id; id = id->next) {
 828                 if (id->dead) {
 829                         continue;
 830                 }
 831
 832                 if (rgid != (gid_t)-1) {
 833                         id->rgid = rgid;
 834                 }
 835
 836                 if (egid != (gid_t)-1) {
 837                         id->egid = egid;
 838                 }
 839
 840                 if (sgid != (gid_t)-1) {
 841                         id->sgid = sgid;
 842                 }
 843         }
 844         pthread_mutex_unlock(&uwrap_id_mutex);
 845
 846         return 0;
 847 }
 848
 849 /*
 850  * SETGID
 851  */
 852 int setgid(gid_t gid)
 853 {
 854         if (!uid_wrapper_enabled()) {
 855                 return libc_setgid(gid);
 856         }
 857
 858         return uwrap_setresgid(gid, -1, -1);
 859 }
 860
 861 #ifdef HAVE_SETEGID
 862 int setegid(gid_t egid)
 863 {
 864         if (!uid_wrapper_enabled()) {
 865                 return libc_setegid(egid);
 866         }
 867
 868         return uwrap_setresgid(-1, egid, -1);
 869 }
 870 #endif
 871
 872 #ifdef HAVE_SETREGID
 873 int setregid(gid_t rgid, gid_t egid)
 874 {
 875         if (!uid_wrapper_enabled()) {
 876                 return libc_setregid(rgid, egid);
 877         }
 878
 879         return uwrap_setresgid(rgid, egid, -1);
 880 }
 881 #endif
 882
 883 #ifdef HAVE_SETRESGID
 884 int setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 885 {
 886         if (!uid_wrapper_enabled()) {
 887                 return libc_setresgid(rgid, egid, sgid);
 888         }
 889
 890         return uwrap_setresgid(rgid, egid, sgid);
 891 }
 892 #endif
 893
 894 /*
 895  * GETGID
 896  */
 897 static gid_t uwrap_getgid(void)
 898 {
 899         struct uwrap_thread *id = uwrap_tls_id;
 900         gid_t gid;
 901
 902         pthread_mutex_lock(&uwrap_id_mutex);
 903         gid = id->rgid;
 904         pthread_mutex_unlock(&uwrap_id_mutex);
 905
 906         return gid;
 907 }
 908
 909 gid_t getgid(void)
 910 {
 911         if (!uid_wrapper_enabled()) {
 912                 return libc_getgid();
 913         }
 914
 915         return uwrap_getgid();
 916 }
 917
 918 /*
 919  * GETEGID
 920  */
 921 static uid_t uwrap_getegid(void)
 922 {
 923         struct uwrap_thread *id = uwrap_tls_id;
 924         gid_t gid;
 925
 926         pthread_mutex_lock(&uwrap_id_mutex);
 927         gid = id->egid;
 928         pthread_mutex_unlock(&uwrap_id_mutex);
 929
 930         return gid;
 931 }
 932
 933 uid_t getegid(void)
 934 {
 935         if (!uid_wrapper_enabled()) {
 936                 return libc_getegid();
 937         }
 938
 939         return uwrap_getegid();
 940 }
 941
 942 static int uwrap_setgroups_thread(size_t size, const gid_t *list)
 943 {
 944         struct uwrap_thread *id = uwrap_tls_id;
 945         int rc = -1;
 946
 947         pthread_mutex_lock(&uwrap_id_mutex);
 948
 949         if (size > 0) {
 950                 gid_t *tmp;
 951
 952                 tmp = realloc(id->groups, sizeof(gid_t) * size);
 953                 if (tmp == NULL) {
 954                         errno = ENOMEM;
 955                         goto out;
 956                 }
 957                 id->groups = tmp;
 958
 959                 id->ngroups = size;
 960                 memcpy(id->groups, list, size * sizeof(gid_t));
 961         }
 962
 963         rc = 0;
 964 out:
 965         pthread_mutex_unlock(&uwrap_id_mutex);
 966
 967         return rc;
 968 }
 969
 970 static int uwrap_setgroups(size_t size, const gid_t *list)
 971 {
 972         struct uwrap_thread *id;
 973         int rc = -1;
 974
 975         pthread_mutex_lock(&uwrap_id_mutex);
 976
 977         if (size > 0) {
 978                 for (id = uwrap.ids; id; id = id->next) {
 979                         gid_t *tmp;
 980
 981                         tmp = realloc(id->groups, sizeof(gid_t) * size);
 982                         if (tmp == NULL) {
 983                                 errno = ENOMEM;
 984                                 goto out;
 985                         }
 986                         id->groups = tmp;
 987
 988                         id->ngroups = size;
 989                         memcpy(id->groups, list, size * sizeof(gid_t));
 990                 }
 991         }
 992
 993         rc = 0;
 994 out:
 995         pthread_mutex_unlock(&uwrap_id_mutex);
 996
 997         return rc;
 998 }
 999
1000 #ifdef HAVE_SETGROUPS_INT
1001 int setgroups(int size, const gid_t *list)
1002 #else
1003 int setgroups(size_t size, const gid_t *list)
1004 #endif
1005 {
1006         if (!uid_wrapper_enabled()) {
1007                 return libc_setgroups(size, list);
1008         }
1009
1010         return uwrap_setgroups(size, list);
1011 }
1012
1013 static int uwrap_getgroups(int size, gid_t *list)
1014 {
1015         struct uwrap_thread *id = uwrap_tls_id;
1016         int ngroups;
1017
1018         pthread_mutex_lock(&uwrap_id_mutex);
1019         ngroups = id->ngroups;
1020
1021         if (size > ngroups) {
1022                 size = ngroups;
1023         }
1024         if (size == 0) {
1025                 goto out;
1026         }
1027         if (size < ngroups) {
1028                 errno = EINVAL;
1029                 ngroups = -1;
1030         }
1031         memcpy(list, id->groups, size * sizeof(gid_t));
1032
1033 out:
1034         pthread_mutex_unlock(&uwrap_id_mutex);
1035
1036         return ngroups;
1037 }
1038
1039 int getgroups(int size, gid_t *list)
1040 {
1041         if (!uid_wrapper_enabled()) {
1042                 return libc_getgroups(size, list);
1043         }
1044
1045         return uwrap_getgroups(size, list);
1046 }
1047
1048 #if (defined(HAVE_SYS_SYSCALL_H) || defined(HAVE_SYSCALL_H)) \
1049     && (defined(SYS_setreuid) || defined(SYS_setreuid32))
1050 static long int uwrap_syscall (long int sysno, va_list vp)
1051 {
1052         long int rc;
1053
1054         switch (sysno) {
1055                 /* gid */
1056                 case SYS_getgid:
1057 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1058                 case SYS_getgid32:
1059 #endif
1060                         {
1061                                 rc = uwrap_getgid();
1062                         }
1063                         break;
1064 #ifdef SYS_getegid
1065                 case SYS_getegid:
1066 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1067                 case SYS_getegid32:
1068 #endif
1069                         {
1070                                 rc = uwrap_getegid();
1071                         }
1072                         break;
1073 #endif /* SYS_getegid */
1074                 case SYS_setgid:
1075 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1076                 case SYS_setgid32:
1077 #endif
1078                         {
1079                                 gid_t gid = (gid_t) va_arg(vp, int);
1080
1081                                 rc = uwrap_setresgid_thread(gid, -1, -1);
1082                         }
1083                         break;
1084                 case SYS_setregid:
1085 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1086                 case SYS_setregid32:
1087 #endif
1088                         {
1089                                 uid_t rgid = (uid_t) va_arg(vp, int);
1090                                 uid_t egid = (uid_t) va_arg(vp, int);
1091
1092                                 rc = uwrap_setresgid_thread(rgid, egid, -1);
1093                         }
1094                         break;
1095 #ifdef SYS_setresgid
1096                 case SYS_setresgid:
1097 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1098                 case SYS_setresgid32:
1099 #endif
1100                         {
1101                                 uid_t rgid = (uid_t) va_arg(vp, int);
1102                                 uid_t egid = (uid_t) va_arg(vp, int);
1103                                 uid_t sgid = (uid_t) va_arg(vp, int);
1104
1105                                 rc = uwrap_setresgid_thread(rgid, egid, sgid);
1106                         }
1107                         break;
1108 #endif /* SYS_setresgid */
1109
1110                 /* uid */
1111                 case SYS_getuid:
1112 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1113                 case SYS_getuid32:
1114 #endif
1115                         {
1116                                 rc = uwrap_getuid();
1117                         }
1118                         break;
1119 #ifdef SYS_geteuid
1120                 case SYS_geteuid:
1121 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1122                 case SYS_geteuid32:
1123 #endif
1124                         {
1125                                 rc = uwrap_geteuid();
1126                         }
1127                         break;
1128 #endif /* SYS_geteuid */
1129                 case SYS_setuid:
1130 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1131                 case SYS_setuid32:
1132 #endif
1133                         {
1134                                 uid_t uid = (uid_t) va_arg(vp, int);
1135
1136                                 rc = uwrap_setresuid_thread(uid, -1, -1);
1137                         }
1138                         break;
1139                 case SYS_setreuid:
1140 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1141                 case SYS_setreuid32:
1142 #endif
1143                         {
1144                                 uid_t ruid = (uid_t) va_arg(vp, int);
1145                                 uid_t euid = (uid_t) va_arg(vp, int);
1146
1147                                 rc = uwrap_setresuid_thread(ruid, euid, -1);
1148                         }
1149                         break;
1150 #ifdef SYS_setresuid
1151                 case SYS_setresuid:
1152 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1153                 case SYS_setresuid32:
1154 #endif
1155                         {
1156                                 uid_t ruid = (uid_t) va_arg(vp, int);
1157                                 uid_t euid = (uid_t) va_arg(vp, int);
1158                                 uid_t suid = (uid_t) va_arg(vp, int);
1159
1160                                 rc = uwrap_setresuid_thread(ruid, euid, suid);
1161                         }
1162                         break;
1163 #endif /* SYS_setresuid */
1164
1165                 /* groups */
1166                 case SYS_setgroups:
1167 #ifdef HAVE_LINUX_32BIT_SYSCALLS
1168                 case SYS_setgroups32:
1169 #endif
1170                         {
1171                                 size_t size = (size_t) va_arg(vp, size_t);
1172                                 gid_t *list = (gid_t *) va_arg(vp, int *);
1173
1174                                 rc = uwrap_setgroups_thread(size, list);
1175                         }
1176                         break;
1177                 default:
1178                         UWRAP_LOG(UWRAP_LOG_DEBUG,
1179                                   "UID_WRAPPER calling non-wrapped syscall %lu\n",
1180                                   sysno);
1181
1182                         rc = libc_vsyscall(sysno, vp);
1183                         break;
1184         }
1185
1186         return rc;
1187 }
1188
1189 #ifdef HAVE_SYSCALL
1190 #ifdef HAVE_SYSCALL_INT
1191 int syscall (int sysno, ...)
1192 #else
1193 long int syscall (long int sysno, ...)
1194 #endif
1195 {
1196 #ifdef HAVE_SYSCALL_INT
1197         int rc;
1198 #else
1199         long int rc;
1200 #endif
1201         va_list va;
1202
1203         va_start(va, sysno);
1204
1205         if (!uid_wrapper_enabled()) {
1206                 rc = libc_vsyscall(sysno, va);
1207                 va_end(va);
1208                 return rc;
1209         }
1210
1211         rc = uwrap_syscall(sysno, va);
1212         va_end(va);
1213
1214         return rc;
1215 }
1216 #endif /* HAVE_SYSCALL */
1217 #endif /* HAVE_SYS_SYSCALL_H || HAVE_SYSCALL_H */
1218
1219 /****************************
1220  * DESTRUCTOR
1221  ***************************/
1222
1223 /*
1224  * This function is called when the library is unloaded and makes sure that
1225  * resources are freed.
1226  */
1227 void uwrap_destructor(void)
1228 {
1229         struct uwrap_thread *u = uwrap.ids;
1230
1231         pthread_mutex_lock(&uwrap_id_mutex);
1232         while (u != NULL) {
1233                 UWRAP_DLIST_REMOVE(uwrap.ids, u);
1234
1235                 SAFE_FREE(u->groups);
1236                 SAFE_FREE(u);
1237
1238                 u = uwrap.ids;
1239         }
1240         pthread_mutex_unlock(&uwrap_id_mutex);
1241
1242         if (uwrap.libc.handle != NULL) {
1243                 dlclose(uwrap.libc.handle);
1244         }
1245 }