tools/nolibc: stackprotector: Avoid stalling program startup if crng is not init yet
PATCH 1/1 tools/nolibc: stackprotector: Avoid stalling program startup if crng is not init yet
We are using the getrandom syscall to get a random seed for the stack protector canary but we are calling it with no flags which means it'll block until there is some real randomness to return.
This means that if the crng is not ready yet program startup will block and if you are unlucky that could be for a long time and look like the program has crashed.
There is a comment in the code about mixing in the pid to make sure the canary isn't 0 even if getrandom fails so it seems ok to pass the non-blocking and insecure flags so it doesn't block and potentially return something even if the crng is not init yet.
---
The insecure flag is apparently from 5.6, I think Willy said before we are trying to keep nolibc working on the oldest LTS kernel. That seems to be 5.10 so I think its ok?
Anyhow, I switched compilers for my nommu target and everything stopped working, tracked it down to this. my other compiler must have not supported the stack protector.
tools/include/nolibc/stackprotector.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
tools/include/nolibc/stackprotector.h +2 -1
@@ -42,7 +42,8 @@ uintptr_t __stack_chk_guard; static __nolibc_no_stack_protector void __stack_chk_init(void) { -__nolibc_syscall3 (__NR_getrandom, &__stack_chk_guard,sizeof (__stack_chk_guard),0 ); +__nolibc_syscall3 (__NR_getrandom, &__stack_chk_guard,sizeof (__stack_chk_guard), +GRND_INSECURE |GRND_NONBLOCK );/* a bit more randomness in case getrandom() fails, ensure the guard is never 0 */ if (__stack_chk_guard != (uintptr_t ) &__stack_chk_guard) __stack_chk_guard ^= (uintptr_t ) &__stack_chk_guard;
Signature · 1 line
2.53.0
Sorry for the spam.
Quoted 5 lines · Daniel Palmer
There is a comment in the code about mixing in the pid to make sure the canary isn't 0 even if getrandom fails so it seems ok to pass the non-blocking and insecure flags so it doesn't block and potentially return something even if the crng is not init yet.
My brain made the pid part up. I checked again add it's not using the pid.. anyhow the code still seems to have been prepared for getrandom failing so it seems ok to let it actually fail.
Thanks,
Daniel
Hi Daniel!
Quoted 8 lines · Daniel Palmer
We are using the getrandom syscall to get a random seed for the stack protector canary but we are calling it with no flags which means it'll block until there is some real randomness to return.
This means that if the crng is not ready yet program startup will block and if you are unlucky that could be for a long time and look like the program has crashed.
Quoted 8 lines
There is a comment in the code about mixing in the pid to make sure the canary isn't 0 even if getrandom fails so it seems ok to pass the non-blocking and insecure flags so it doesn't block and potentially return something even if the crng is not init yet.
Fixes 7188d4637e95 ("tools/nolibc: add support for stack protector")Signed-off-by Daniel Palmer <[email protected]>
Quoted 5 lines
---
The insecure flag is apparently from 5.6, I think Willy said before we are trying to keep nolibc working on the oldest LTS kernel. That seems to be 5.10 so I think its ok?
Sounds reasonable. We could also condition the flag to its existence if it causes issues.
Quoted 3 lines
Anyhow, I switched compilers for my nommu target and everything stopped working, tracked it down to this. my other compiler must have not supported the stack protector.
Possible, indeed.
Thanks!
Willy
Quoted 21 lines
tools/include/nolibc/stackprotector.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)tools/include/nolibc/stackprotector.h +2
-1@@ -42,7 +42,8 @@ uintptr_t __stack_chk_guard; static __nolibc_no_stack_protector void __stack_chk_init(void) { -__nolibc_syscall3 (__NR_getrandom, &__stack_chk_guard,sizeof (__stack_chk_guard),0 ); +__nolibc_syscall3 (__NR_getrandom, &__stack_chk_guard,sizeof (__stack_chk_guard), +GRND_INSECURE |GRND_NONBLOCK );/* a bit more randomness in case getrandom() fails, ensure the guard is never 0 */ if (__stack_chk_guard != (uintptr_t ) &__stack_chk_guard) __stack_chk_guard ^= (uintptr_t ) &__stack_chk_guard;Signature · 1 line
2.53.0
Thomas Weißschuh
maintainerQuoted 20 lines · Willy Tarreau
Quoted 8 lines · Daniel Palmer
We are using the getrandom syscall to get a random seed for the stack protector canary but we are calling it with no flags which means it'll block until there is some real randomness to return.
This means that if the crng is not ready yet program startup will block and if you are unlucky that could be for a long time and look like the program has crashed.
Quoted 8 lines
There is a comment in the code about mixing in the pid to make sure the canary isn't 0 even if getrandom fails so it seems ok to pass the non-blocking and insecure flags so it doesn't block and potentially return something even if the crng is not init yet.
Fixes 7188d4637e95 ("tools/nolibc: add support for stack protector")Signed-off-by Daniel Palmer <[email protected]>Acked-by Willy Tarreau <[email protected]>
Quoted 8 lines
Quoted 5 lines
---
The insecure flag is apparently from 5.6, I think Willy said before we are trying to keep nolibc working on the oldest LTS kernel. That seems to be 5.10 so I think its ok?
Sounds reasonable. We could also condition the flag to its existence if it causes issues.
IMO we could even not use GRND_INSECURE and only use GRND_NONBLOCK.
Quoted 3 lines
Quoted 3 lines
Anyhow, I switched compilers for my nommu target and everything stopped working, tracked it down to this. my other compiler must have not supported the stack protector.
Did the random pool *never* fully initialize?
That sounds weird.
(...)
Thomas
Hi Thomas,
Quoted 6 lines · Thomas Weißschuh
Quoted 3 lines
Quoted 3 lines
Anyhow, I switched compilers for my nommu target and everything stopped working, tracked it down to this. my other compiler must have not supported the stack protector.
Did the random pool *never* fully initialize?
That sounds weird.
The crng init message is eventually printed after a while if I interact with the shell[0].
Since my init, shell, everything is written with nolibc now there is so little disk activity etc I don't think there are enough interrupts happening to collect any randomness.
Maybe something to save some seeding data between boots is the next tool I need to write.
0 - https://gist.github.com/fifteenhex/d4a284f34a605702f98a3db68261f46e
Willy Tarreau
maintainerQuoted 8 lines · Daniel Palmer
Hi Thomas,
Quoted 4 lines · Thomas Weißschuh
Quoted 3 lines
Quoted 3 lines
Anyhow, I switched compilers for my nommu target and everything stopped working, tracked it down to this. my other compiler must have not supported the stack protector.
Quoted 8 lines
Quoted 2 lines
Did the random pool *never* fully initialize?
That sounds weird.The crng init message is eventually printed after a while if I interact with the shell[0].
Since my init, shell, everything is written with nolibc now there is so little disk activity etc I don't think there are enough interrupts happening to collect any randomness.
Yeah I've known this problem as well for years on small headless systems that never finish to boot if you ever called getrandom(), before GRND_INSECURE existed. Several of us used to patch it not to wait or used to change boot code not to call this function.
Quoted 2 lines
Maybe something to save some seeding data between boots is the next tool I need to write.
Since modern kernels support GRND_INSECURE, I suspect you would just be wasting your time. Better rely on this for boot code.
Willy
Thomas Weißschuh
maintainerQuoted 2 lines · Willy Tarreau
Quoted 1 line · Daniel Palmer
On Fri, 22 May 2026 at 23:46, Thomas Weißschuh <[email protected]> wrote:
(...)
Quoted 5 lines
Quoted 2 lines
Maybe something to save some seeding data between boots is the next tool I need to write.
Since modern kernels support
GRND_INSECURE, I suspect you would just be wasting your time. Better rely on this for boot code.
If it's good enough for Willy, it is certainly good enough for me, too. Or we could switch to AT_RANDOM, but the current aproach is fine for me.
Thomas
Hi Thomas, Willy,
Quoted 10 lines · Thomas Weißschuh
Quoted 6 lines · Willy Tarreau
Quoted 3 lines
The insecure flag is apparently from 5.6, I think Willy said before we are trying to keep nolibc working on the oldest LTS kernel. That seems to be 5.10 so I think its ok?
Sounds reasonable. We could also condition the flag to its existence if it causes issues.
IMO we could even not use
GRND_INSECUREand only useGRND_NONBLOCK.
How about this:
static __nolibc_no_stack_protector void __stack_chk_init(void)
{
int ret = -EINVAL;
/* GRND_INSECURE is available in kernel 5.6+ */
#ifdef GRND_INSECURE
ret = __nolibc_syscall3(__NR_getrandom, &__stack_chk_guard,
sizeof(__stack_chk_guard),
GRND_INSECURE | GRND_NONBLOCK);#endif
/* GRND_INSECURE wasn't defined at build time or the above call
to getrandom failed because
* the running kernel didn't understand it.
*/
if (ret == -EINVAL) {
__nolibc_syscall3(__NR_getrandom, &__stack_chk_guard,
sizeof(__stack_chk_guard),
GRND_NONBLOCK);
}
/* a bit more randomness in case getrandom() fails, ensure the
guard is never 0 */
if (__stack_chk_guard != (uintptr_t) &__stack_chk_guard)
__stack_chk_guard ^= (uintptr_t) &__stack_chk_guard;
}I think that would allow building with >=5.6 headers and running on <5.6 and building on <5.6.
Maybe its too much. :)
Thanks,
Daniel