mirror of
git://sourceware.org/git/glibc.git
synced 2024-11-27 03:41:23 +08:00
169 lines
3.4 KiB
C
169 lines
3.4 KiB
C
/* Test program for making nonexecutable stacks executable
|
|
on load of a DSO that requires executable stacks. */
|
|
|
|
#include <dlfcn.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <error.h>
|
|
|
|
static void
|
|
print_maps (void)
|
|
{
|
|
#if 0
|
|
char *cmd = NULL;
|
|
asprintf (&cmd, "cat /proc/%d/maps", getpid ());
|
|
system (cmd);
|
|
free (cmd);
|
|
#endif
|
|
}
|
|
|
|
static void deeper (void (*f) (void));
|
|
|
|
#if USE_PTHREADS
|
|
# include <pthread.h>
|
|
|
|
static void *
|
|
tryme_thread (void *f)
|
|
{
|
|
(*((void (*) (void)) f)) ();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static pthread_barrier_t startup_barrier, go_barrier;
|
|
static void *
|
|
waiter_thread (void *arg)
|
|
{
|
|
void **f = arg;
|
|
pthread_barrier_wait (&startup_barrier);
|
|
pthread_barrier_wait (&go_barrier);
|
|
|
|
(*((void (*) (void)) *f)) ();
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
static bool allow_execstack = true;
|
|
|
|
|
|
static int
|
|
do_test (void)
|
|
{
|
|
/* Check whether SELinux is enabled and disallows executable stacks. */
|
|
FILE *fp = fopen ("/selinux/enforce", "r");
|
|
if (fp != NULL)
|
|
{
|
|
char *line = NULL;
|
|
size_t linelen = 0;
|
|
|
|
bool enabled = false;
|
|
ssize_t n = getline (&line, &linelen, fp);
|
|
if (n > 0 && line[0] != '0')
|
|
enabled = true;
|
|
|
|
fclose (fp);
|
|
|
|
if (enabled)
|
|
{
|
|
fp = fopen ("/selinux/booleans/allow_execstack", "r");
|
|
if (fp != NULL)
|
|
{
|
|
n = getline (&line, &linelen, fp);
|
|
if (n > 0 && line[0] == '0')
|
|
allow_execstack = false;
|
|
}
|
|
|
|
fclose (fp);
|
|
}
|
|
}
|
|
|
|
printf ("executable stacks %sallowed\n", allow_execstack ? "" : "not ");
|
|
|
|
static void *f; /* Address of this is used in other threads. */
|
|
|
|
#if USE_PTHREADS
|
|
/* Create some threads while stacks are nonexecutable. */
|
|
#define N 5
|
|
pthread_t thr[N];
|
|
|
|
pthread_barrier_init (&startup_barrier, NULL, N + 1);
|
|
pthread_barrier_init (&go_barrier, NULL, N + 1);
|
|
|
|
for (int i = 0; i < N; ++i)
|
|
{
|
|
int rc = pthread_create (&thr[i], NULL, &waiter_thread, &f);
|
|
if (rc)
|
|
error (1, rc, "pthread_create");
|
|
}
|
|
|
|
/* Make sure they are all there using their stacks. */
|
|
pthread_barrier_wait (&startup_barrier);
|
|
puts ("threads waiting");
|
|
#endif
|
|
|
|
print_maps ();
|
|
|
|
/* Loading this module should force stacks to become executable. */
|
|
void *h = dlopen ("tst-execstack-mod.so", RTLD_LAZY);
|
|
if (h == NULL)
|
|
{
|
|
printf ("cannot load: %s\n", dlerror ());
|
|
return allow_execstack;
|
|
}
|
|
|
|
f = dlsym (h, "tryme");
|
|
if (f == NULL)
|
|
{
|
|
printf ("symbol not found: %s\n", dlerror ());
|
|
return 1;
|
|
}
|
|
|
|
/* Test if that really made our stack executable.
|
|
The `tryme' function should crash if not. */
|
|
|
|
(*((void (*) (void)) f)) ();
|
|
|
|
print_maps ();
|
|
|
|
/* Test that growing the stack region gets new executable pages too. */
|
|
deeper ((void (*) (void)) f);
|
|
|
|
print_maps ();
|
|
|
|
#if USE_PTHREADS
|
|
/* Test that a fresh thread now gets an executable stack. */
|
|
{
|
|
pthread_t th;
|
|
int rc = pthread_create (&th, NULL, &tryme_thread, f);
|
|
if (rc)
|
|
error (1, rc, "pthread_create");
|
|
}
|
|
|
|
puts ("threads go");
|
|
/* The existing threads' stacks should have been changed.
|
|
Let them run to test it. */
|
|
pthread_barrier_wait (&go_barrier);
|
|
|
|
pthread_exit (! allow_execstack);
|
|
#endif
|
|
|
|
return ! allow_execstack;
|
|
}
|
|
|
|
static void
|
|
deeper (void (*f) (void))
|
|
{
|
|
char stack[1100 * 1024];
|
|
memfrob (stack, sizeof stack);
|
|
(*f) ();
|
|
memfrob (stack, sizeof stack);
|
|
}
|
|
|
|
|
|
#define TEST_FUNCTION do_test ()
|
|
#include "../test-skeleton.c"
|