Skip to contentSkip to conversation

tools/nolibc: stackprotector: Avoid stalling program startup if crng is not init yet

PATCH In review Daniel Palmer 3 participants 8 messages May 22 – May 24 Nolibc header file

lore
Share & tools
lore
#0 lore raw

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.

Fixes 7188d4637e95 ("tools/nolibc: add support for stack protector")

---

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
index e11c20c75465..916a92062ba0 100644
@@ -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
#1 lore raw

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

maintainer Acked-by on v1 1/1
#2 lore raw
In reply to Daniel Palmer

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")
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
index e11c20c75465..916a92062ba0 100644
@@ -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
#3 lore raw
Quoted 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")
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

#4 lore raw

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

maintainer
#5 lore raw
Quoted 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

#6 lore raw
Quoted 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

#7 lore raw
In reply to Thomas Weißschuh

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_INSECURE and only use GRND_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