elf/tst-tunables-enable_secure.c

   1 /* Check GLIBC_TUNABLES parsing for enable_secure.
   2    Copyright (C) 2024-2025 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library 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 GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <array_length.h>
  20 /* The test uses the tunable_env_alias_list size, which is only exported for
  21    ld.so.  This will result in a copy of tunable_list and
  22    tunable_env_alias_list, which is ununsed by the test itself.  */
  23 #define TUNABLES_INTERNAL 1
  24 #include <dl-tunables.h>
  25 #include <getopt.h>
  26 #include <intprops.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <support/capture_subprocess.h>
  30 #include <support/check.h>
  31 #include <sys/auxv.h>
  32 #include <unistd.h>
  33
  34 static int restart;
  35 #define CMDLINE_OPTIONS \
  36   { "restart", no_argument, &restart, 1 },
  37
  38 static const struct test_t
  39 {
  40   const char *env;
  41   const char *extraenv;
  42   bool check_multiple;
  43   int32_t expected_malloc_check;
  44   int32_t expected_enable_secure;
  45 } tests[] =
  46 {
  47   /* Expected tunable format.  */
  48   /* Tunables should be ignored if enable_secure is set. */
  49   {
  50     "GLIBC_TUNABLES=glibc.malloc.check=2:glibc.rtld.enable_secure=1",
  51     NULL,
  52     false,
  53     0,
  54     1,
  55   },
  56   /* Tunables should be ignored if enable_secure is set. */
  57   {
  58     "GLIBC_TUNABLES=glibc.rtld.enable_secure=1:glibc.malloc.check=2",
  59     NULL,
  60     false,
  61     0,
  62     1,
  63   },
  64   /* Tunables should be set if enable_secure is unset. */
  65   {
  66     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0:glibc.malloc.check=2",
  67     NULL,
  68     false,
  69     2,
  70     0,
  71   },
  72   /* Tunables should be ignored if enable_secure is set. */
  73   {
  74     "GLIBC_TUNABLES=glibc.malloc.check=2:glibc.rtld.enable_secure=1",
  75     "MALLOC_CHECK_=2",
  76     false,
  77     0,
  78     1,
  79   },
  80   /* Same as before, but with enviroment alias prior GLIBC_TUNABLES.  */
  81   {
  82     "MALLOC_CHECK_=2",
  83     "GLIBC_TUNABLES=glibc.malloc.check=2:glibc.rtld.enable_secure=1",
  84     false,
  85     0,
  86     1,
  87   },
  88   /* Tunables should be ignored if enable_secure is set. */
  89   {
  90     "GLIBC_TUNABLES=glibc.rtld.enable_secure=1:glibc.malloc.check=2",
  91     "MALLOC_CHECK_=2",
  92     false,
  93     0,
  94     1,
  95   },
  96   {
  97     "MALLOC_CHECK_=2",
  98     "GLIBC_TUNABLES=glibc.rtld.enable_secure=1:glibc.malloc.check=2",
  99     false,
 100     0,
 101     1,
 102   },
 103   /* Tunables should be set if enable_secure is unset. */
 104   {
 105     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0:glibc.malloc.check=2",
 106     /* Tunable have precedence over the environment variable.  */
 107     "MALLOC_CHECK_=1",
 108     false,
 109     2,
 110     0,
 111   },
 112   {
 113     "MALLOC_CHECK_=1",
 114     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0:glibc.malloc.check=2",
 115     /* Tunable have precedence over the environment variable.  */
 116     false,
 117     2,
 118     0,
 119   },
 120   /* Tunables should be set if enable_secure is unset. */
 121   {
 122     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0",
 123     /* Tunable have precedence over the environment variable.  */
 124     "MALLOC_CHECK_=1",
 125     false,
 126     1,
 127     0,
 128   },
 129   /* Tunables should be set if enable_secure is unset. */
 130   {
 131     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0",
 132     /* Tunable have precedence over the environment variable.  */
 133     "MALLOC_CHECK_=1",
 134     false,
 135     1,
 136     0,
 137   },
 138   /* Check with tunables environment variable alias set multiple times.  */
 139   {
 140     "GLIBC_TUNABLES=glibc.rtld.enable_secure=1:glibc.malloc.check=2",
 141     "MALLOC_CHECK_=2",
 142     true,
 143     0,
 144     1,
 145   },
 146   /* Tunables should be set if enable_secure is unset. */
 147   {
 148     "GLIBC_TUNABLES=glibc.rtld.enable_secure=0",
 149     /* Tunable have precedence over the environment variable.  */
 150     "MALLOC_CHECK_=1",
 151     true,
 152     1,
 153     0,
 154   },
 155 };
 156
 157 static int
 158 handle_restart (int i)
 159 {
 160   if (tests[i].expected_enable_secure == 1)
 161     TEST_COMPARE (1, __libc_enable_secure);
 162   else
 163     TEST_COMPARE (tests[i].expected_enable_secure,
 164                   TUNABLE_GET_FULL (glibc, rtld, enable_secure, int32_t,
 165                                      NULL));
 166   TEST_COMPARE (tests[i].expected_malloc_check,
 167                 TUNABLE_GET_FULL (glibc, malloc, check, int32_t, NULL));
 168   return 0;
 169 }
 170
 171 static int
 172 do_test (int argc, char *argv[])
 173 {
 174   /* We must have either:
 175      - One or four parameters left if called initially:
 176        + path to ld.so         optional
 177        + "--library-path"      optional
 178        + the library path      optional
 179        + the application name
 180        + the test to check  */
 181
 182   TEST_VERIFY_EXIT (argc == 2 || argc == 5);
 183
 184   if (restart)
 185     return handle_restart (atoi (argv[1]));
 186
 187   char nteststr[INT_BUFSIZE_BOUND (int)];
 188
 189   char *spargv[10];
 190   {
 191     int i = 0;
 192     for (; i < argc - 1; i++)
 193       spargv[i] = argv[i + 1];
 194     spargv[i++] = (char *) "--direct";
 195     spargv[i++] = (char *) "--restart";
 196     spargv[i++] = nteststr;
 197     spargv[i] = NULL;
 198   }
 199
 200   enum { tunable_num_env_alias = array_length (tunable_env_alias_list) };
 201
 202   for (int i = 0; i < array_length (tests); i++)
 203     {
 204       snprintf (nteststr, sizeof nteststr, "%d", i);
 205
 206       printf ("[%d] Spawned test for %s\n", i, tests[i].env);
 207       setenv ("GLIBC_TUNABLES", tests[i].env, 1);
 208
 209       char *envp[2 + tunable_num_env_alias + 1] =
 210       {
 211         (char *) tests[i].env,
 212         (char *) tests[i].extraenv,
 213         NULL,
 214       };
 215       if (tests[i].check_multiple)
 216         {
 217           int j;
 218           for (j=0; j < tunable_num_env_alias; j++)
 219             envp[j + 2] = (char *) tests[i].extraenv;
 220           envp[j + 2] = NULL;
 221         }
 222
 223       struct support_capture_subprocess result
 224         = support_capture_subprogram (spargv[0], spargv, envp);
 225       support_capture_subprocess_check (&result, "tst-tunables-enable_secure",
 226                                         0, sc_allow_stderr);
 227       support_capture_subprocess_free (&result);
 228     }
 229
 230   return 0;
 231 }
 232
 233 #define TEST_FUNCTION_ARGV do_test
 234 #include <support/test-driver.c>