tests/test_syscall_setresuid32.c

   1 #include "config.h"
   2
   3 #include <stdarg.h>
   4 #include <stddef.h>
   5 #include <setjmp.h>
   6 #include <cmocka.h>
   7
   8 #include <errno.h>
   9 #include <sys/types.h>
  10 #include <unistd.h>
  11
  12 #include <pwd.h>
  13
  14 #ifdef HAVE_SYS_SYSCALL_H
  15 #include <sys/syscall.h>
  16 #endif
  17 #ifdef HAVE_SYSCALL_H
  18 #include <syscall.h>
  19 #endif
  20
  21 static void test_uwrap_syscall_setresuid32(void **state)
  22 {
  23         long int rc;
  24         uid_t u;
  25 #ifdef HAVE_GETRESUID
  26         uid_t cp_ruid, cp_euid, cp_suid;
  27 #endif
  28
  29         (void) state; /* unused */
  30
  31 #ifdef HAVE_GETRESUID
  32         cp_ruid = cp_euid = cp_suid = -1;
  33         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
  34         assert_return_code(rc, errno);
  35         assert_int_equal(cp_ruid, 0);
  36         assert_int_equal(cp_euid, 0);
  37         assert_int_equal(cp_suid, 0);
  38 #endif
  39         u = geteuid();
  40         assert_int_equal(u, 0);
  41
  42         rc = syscall(SYS_setresuid32, -1, -1, -1);
  43         assert_return_code(rc, errno);
  44
  45         rc = syscall(SYS_setresuid32, 0x4444, 0x5555, -1);
  46         assert_return_code(rc, errno);
  47
  48 #ifdef HAVE_GETRESUID
  49         cp_ruid = cp_euid = cp_suid = -1;
  50         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
  51         assert_return_code(rc, errno);
  52         assert_int_equal(cp_ruid, 0x4444);
  53         assert_int_equal(cp_euid, 0x5555);
  54         assert_int_equal(cp_suid, 0);
  55 #endif
  56
  57         u = getuid();
  58         assert_int_equal(u, 0x4444);
  59
  60         u = geteuid();
  61         assert_int_equal(u, 0x5555);
  62
  63         /* We can go back cause the suid is 0 */
  64         rc = syscall(SYS_setresuid32, 0, -1, -1);
  65         assert_return_code(rc, errno);
  66
  67 #ifdef HAVE_GETRESUID
  68         cp_ruid = cp_euid = cp_suid = -1;
  69         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
  70         assert_return_code(rc, errno);
  71         assert_int_equal(cp_ruid, 0);
  72         assert_int_equal(cp_euid, 0x5555);
  73         assert_int_equal(cp_suid, 0);
  74 #endif
  75
  76         u = getuid();
  77         assert_int_equal(u, 0);
  78
  79         rc = syscall(SYS_setresuid32, -1, 0, -1);
  80         assert_return_code(rc, errno);
  81
  82 #ifdef HAVE_GETRESUID
  83         cp_ruid = cp_euid = cp_suid = -1;
  84         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
  85         assert_return_code(rc, errno);
  86         assert_int_equal(cp_ruid, 0);
  87         assert_int_equal(cp_euid, 0);
  88         assert_int_equal(cp_suid, 0);
  89 #endif
  90
  91         u = geteuid();
  92         assert_int_equal(u, 0);
  93
  94         rc = syscall(SYS_setresuid32, 0, 0x5555, 0x6666);
  95         assert_return_code(rc, errno);
  96
  97 #ifdef HAVE_GETRESUID
  98         cp_ruid = cp_euid = cp_suid = -1;
  99         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 100         assert_return_code(rc, errno);
 101         assert_int_equal(cp_ruid, 0);
 102         assert_int_equal(cp_euid, 0x5555);
 103         assert_int_equal(cp_suid, 0x6666);
 104 #endif
 105
 106         /*
 107          * The euid needs to be 0 in order to change to an
 108          * unknown value (here 0x4444)
 109          */
 110         rc = syscall(SYS_setresuid32, 0x5555, 0x6666, 0x4444);
 111         assert_int_equal(rc, -1);
 112         assert_int_equal(errno, EPERM);
 113
 114 #ifdef HAVE_GETRESUID
 115         cp_ruid = cp_euid = cp_suid = -1;
 116         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 117         assert_return_code(rc, errno);
 118         assert_int_equal(cp_ruid, 0);
 119         assert_int_equal(cp_euid, 0x5555);
 120         assert_int_equal(cp_suid, 0x6666);
 121 #endif
 122
 123         /* But we can rotate the values */
 124         errno = 0;
 125         rc = syscall(SYS_setresuid32, 0x5555, 0x6666, 0);
 126         assert_return_code(rc, errno);
 127
 128 #ifdef HAVE_GETRESUID
 129         cp_ruid = cp_euid = cp_suid = -1;
 130         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 131         assert_return_code(rc, errno);
 132         assert_int_equal(cp_ruid, 0x5555);
 133         assert_int_equal(cp_euid, 0x6666);
 134         assert_int_equal(cp_suid, 0);
 135 #endif
 136
 137         /*
 138          * The euid needs to be 0 in order to change to an
 139          * unknown value (here 0x4444)
 140          */
 141         rc = syscall(SYS_setresuid32, 0x5555, 0x6666, 0x4444);
 142         assert_int_equal(rc, -1);
 143         assert_int_equal(errno, EPERM);
 144
 145 #ifdef HAVE_GETRESUID
 146         cp_ruid = cp_euid = cp_suid = -1;
 147         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 148         assert_return_code(rc, errno);
 149         assert_int_equal(cp_ruid, 0x5555);
 150         assert_int_equal(cp_euid, 0x6666);
 151         assert_int_equal(cp_suid, 0);
 152 #endif
 153
 154         /* But we can rotate the values */
 155         rc = syscall(SYS_setresuid32, 0x5555, 0, 0x6666);
 156         assert_return_code(rc, errno);
 157
 158 #ifdef HAVE_GETRESUID
 159         cp_ruid = cp_euid = cp_suid = -1;
 160         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 161         assert_return_code(rc, errno);
 162         assert_int_equal(cp_ruid, 0x5555);
 163         assert_int_equal(cp_euid, 0);
 164         assert_int_equal(cp_suid, 0x6666);
 165 #endif
 166
 167         /*
 168          * With euid == 0 we can change to completely unrelated values.
 169          */
 170         rc = syscall(SYS_setresuid32, 0x1111, 0x2222, 0x3333);
 171         assert_return_code(rc, errno);
 172
 173 #ifdef HAVE_GETRESUID
 174         cp_ruid = cp_euid = cp_suid = -1;
 175         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 176         assert_return_code(rc, errno);
 177         assert_int_equal(cp_ruid, 0x1111);
 178         assert_int_equal(cp_euid, 0x2222);
 179         assert_int_equal(cp_suid, 0x3333);
 180 #endif
 181
 182         rc = syscall(SYS_setresuid32, 0, -1, -1);
 183         assert_int_equal(rc, -1);
 184         assert_int_equal(errno, EPERM);
 185
 186 #ifdef HAVE_GETRESUID
 187         cp_ruid = cp_euid = cp_suid = -1;
 188         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 189         assert_return_code(rc, errno);
 190         assert_int_equal(cp_ruid, 0x1111);
 191         assert_int_equal(cp_euid, 0x2222);
 192         assert_int_equal(cp_suid, 0x3333);
 193 #endif
 194
 195         rc = syscall(SYS_setresuid32, -1, 0, -1);
 196         assert_int_equal(rc, -1);
 197         assert_int_equal(errno, EPERM);
 198
 199 #ifdef HAVE_GETRESUID
 200         cp_ruid = cp_euid = cp_suid = -1;
 201         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 202         assert_return_code(rc, errno);
 203         assert_int_equal(cp_ruid, 0x1111);
 204         assert_int_equal(cp_euid, 0x2222);
 205         assert_int_equal(cp_suid, 0x3333);
 206 #endif
 207
 208         rc = syscall(SYS_setresuid32, -1, -1, 0);
 209         assert_int_equal(rc, -1);
 210         assert_int_equal(errno, EPERM);
 211
 212 #ifdef HAVE_GETRESUID
 213         cp_ruid = cp_euid = cp_suid = -1;
 214         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 215         assert_return_code(rc, errno);
 216         assert_int_equal(cp_ruid, 0x1111);
 217         assert_int_equal(cp_euid, 0x2222);
 218         assert_int_equal(cp_suid, 0x3333);
 219 #endif
 220
 221         /*
 222          * We can still roate the values
 223          */
 224         rc = syscall(SYS_setresuid32, 0x2222, 0x3333, 0x1111);
 225         assert_return_code(rc, errno);
 226
 227 #ifdef HAVE_GETRESUID
 228         cp_ruid = cp_euid = cp_suid = -1;
 229         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 230         assert_return_code(rc, errno);
 231         assert_int_equal(cp_ruid, 0x2222);
 232         assert_int_equal(cp_euid, 0x3333);
 233         assert_int_equal(cp_suid, 0x1111);
 234 #endif
 235
 236         /*
 237          * We can still roate the values
 238          */
 239         rc = syscall(SYS_setresuid32, 0x3333, 0x1111, 0x2222);
 240         assert_return_code(rc, errno);
 241
 242 #ifdef HAVE_GETRESUID
 243         cp_ruid = cp_euid = cp_suid = -1;
 244         rc = getresuid(&cp_ruid, &cp_euid, &cp_suid);
 245         assert_return_code(rc, errno);
 246         assert_int_equal(cp_ruid, 0x3333);
 247         assert_int_equal(cp_euid, 0x1111);
 248         assert_int_equal(cp_suid, 0x2222);
 249 #endif
 250 }
 251
 252 int main(void) {
 253         int rc;
 254
 255         const struct CMUnitTest uwrap_tests[] = {
 256                 cmocka_unit_test(test_uwrap_syscall_setresuid32),
 257         };
 258
 259         rc = cmocka_run_group_tests(uwrap_tests, NULL, NULL);
 260
 261         return rc;
 262 }