Imposta dimensione dello stack con setrlimit () e provocare un overflow dello stack / segfault
-
29-09-2019 - |
Domanda
Nell'esempio riportato di seguito cerco di impostare la stacksize a 1kb.
Perché è ora possibile allocare una matrice di int nello stack con 8kb
dimensione in foo()
?
#include <stdio.h>
#include <sys/resource.h>
void foo(void);
int main() {
struct rlimit lim = {1024, 1024};
if (setrlimit(RLIMIT_STACK, &lim) == -1)
return 1;
foo();
return 0;
}
void foo() {
unsigned ints[2048];
printf("foo: %u\n", ints[2047]=42);
}
Soluzione
Il limite viene impostato immediatamente, ma controllata solo quando si cerca di allocare una nuova pila o cercando di far crescere lo stack esistente. Un grep per RLIMIT_STACK ( o un LXR ricerca identificatore ) sulle sorgenti del kernel dovrebbe dire .
A quanto pare, la dimensione iniziale dello stack è tutto ciò che è necessario per il nome del file + ENV stringhe + arg corde più alcune pagine in più allocate su setup_arg_pages
(20 pagine in 2.6.33 1 , 2 , 128 Kb su 2.6.34 3 ).
In sintesi:
initial stack size = MIN(size for filename + arg strings + env strings + extra pages, MAX(size for filename + arg strings + env strings, RLIMIT_STACK))
dove
size for filename + arg strings + env strings <= MAX(ARG_MAX(32 pages), RLIMIT_STACK/4)
Inoltre, i kernel con la patch exec-shield
di Ingo Molnar (Fedora, Ubuntu, ...) hanno un EXEC_STACK_BIAS aggiuntiva "(2MB di più per gli effetti di copertura di randomizzazione.)" , vedo la chiamata alla nuova funzione over_stack_limit()
da acct_stack_growth()
( [Ubuntu1] , [Ubuntu2] , [Ubuntu3] ).
Ho modificato il programma originale per mostrare questo:
#include <stdio.h>
#include <sys/resource.h>
void foo(void);
int main(int argc, char *argv[]) {
struct rlimit lim = {1, 1};
if (argc > 1 && argv[1][0] == '-' && argv[1][8]=='l') {
printf("limiting stack size\n");
if (setrlimit(RLIMIT_STACK, &lim) == -1) {
printf("rlimit failed\n");
return 1;
}
}
foo();
return 0;
}
void foo() {
unsigned ints[32768];
printf("foo: %u\n", ints[2047]=42);
}
che si traduce in:
$./rl
foo: 42
$./rl -l
limiting stack size
Segmentation fault
$
Altri suggerimenti
Credo che setrlimit
mosse ai "puntatori di risorse" ma non si applica i nuovi limiti fino a exec
una nuova copia del programma.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/resource.h>
void foo(int chk) {
unsigned ints[2048];
ints[2047] = 42;
printf("foo %d: %u\n", chk, ints[2047]);
}
int main(int argc, char **argv) {
char *newarg[] = { "argv[0]", "one", "two" };
char *newenv[] = { NULL };
struct rlimit lim;
newarg[0] = argv[0];
getrlimit(RLIMIT_STACK, &lim);
printf("lim: %d / %d\n", (int)lim.rlim_cur, (int)lim.rlim_max);
switch (argc) {
case 1: /* first call from command line */
lim.rlim_cur = 65536;
lim.rlim_max = 65536;
if (setrlimit(RLIMIT_STACK, &lim) == -1) return EXIT_FAILURE;
newarg[2] = NULL;
foo(1);
execve(argv[0], newarg, newenv);
break;
case 2: /* second call */
lim.rlim_cur = 1024;
lim.rlim_max = 1024;
if (setrlimit(RLIMIT_STACK, &lim) == -1) return EXIT_FAILURE;
foo(2);
execve(argv[0], newarg, newenv);
break;
default: /* third call */
foo(3);
break;
}
return 0;
}
E una corsa di prova:
$ ./a.out lim: 8388608 / -1 foo 1: 42 lim: 65536 / 65536 foo 2: 42 Killed
Perché il processo viene ucciso prima di stampare i limiti (e prima di chiamare foo), non lo so.