perf: optimize CSP nonce generation

[Tunglies]

Pre-allocate nonces Vec and reuse a single buffer with write! instead of format!, reducing heap allocations when replacing tokens.

Adjust CSP nonce buffer size based on target pointer width

[github-actions]

Package Changes Through 282ed06

There are 1 changes which include tauri with patch

Planned Package Versions

The following package releases are the planned based on the context of changes in this pull request.

package	current	next
tauri	2.9.1	2.9.2

Add another change file through the GitHub UI by following this link.

---

Read about change files or the docs at github.com/jbolda/covector

[Legend-Master]

@lucasfernog do you remember why we used usize here at the first place (tracing back to cf54dcf)? It doesn't quite make sense to me

[vrmiguel]

Maybe I don't get the question, but the code is still using a usize there, just that it's using its underlying byte representation instead, right?

In any case, seems like this code can be simplified down to:

let mut raw = [0u8; std::mem::size_of::<usize>()];
getrandom::fill(&mut raw).expect("failed to get random bytes");
let nonce = usize::from_ne_bytes(raw);

Or even:

let mut raw = 0_usize.to_ne_bytes();
getrandom::fill(&mut raw).expect("failed to get random bytes");
let nonce = usize::from_ne_bytes(raw);

[Legend-Master]

I meant it doesn't make sense to make nonce length depends on target pointer size

[vrmiguel]

Are these capacities meant to be how many bytes to alloc to store 'nonce-{0..usize::MAX}'? If so, isn't it a bit oversized for 32 and 16 ptr widths? Feels like it should be 18 and 13 respectively, unless I'm missing something

If we want to be a bit fancy-pants (😛) we could use this helper function:

const fn nonce_source_capacity() -> usize {
    // 'nonce-' prefix + digits of usize::max + closing quote
    8 + usize::MAX.ilog10() as usize + 1
}

(You can test that by replacing usize for u64, u32 and u16 respectively)

[vrmiguel]

Reusing buf doesn't seem helpful in this scenario, if we'll clone it anyway. It means that the code will allocate nonces.len()+1 times

for nonce in nonces {
      let mut buf = String::with_capacity(nonce_capacity());
      write!(&mut buf, "'nonce-{}'", nonce).unwrap();
      sources.push(buf);
}

Something like that ^ would allocate n times rather than n+1 times

[Legend-Master]

I honestly doubt these optimizations will actually make any differences, format! Itself is quite optimized to estimate the buffer size already