[PATCH libcrypto v2 1/3] wifi: iwlwifi: trans: rename at_least variable to min_mode

[PATCH libcrypto v2 1/3] wifi: iwlwifi: trans: rename at_least variable to min_mode

[Jason A. Donenfeld]

The subsequent commit is going to add a macro that redefines `at_least`
to mean something else. Given that the usage here in iwlwifi is the only
use of that identifier in the whole kernel, just rename it to a more
fitting name, `min_mode`.

Cc: Miri Korenblit <miriam.rachel.korenblit@intel.com>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 drivers/net/wireless/intel/iwlwifi/iwl-trans.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
index 5232f66c2d52..cc8a84018f70 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
@@ -129,7 +129,7 @@ static enum iwl_reset_mode
 iwl_trans_determine_restart_mode(struct iwl_trans *trans)
 {
 	struct iwl_trans_dev_restart_data *data;
-	enum iwl_reset_mode at_least = 0;
+	enum iwl_reset_mode min_mode = 0;
 	unsigned int index;
 	static const enum iwl_reset_mode escalation_list_old[] = {
 		IWL_RESET_MODE_SW_RESET,
@@ -173,11 +173,11 @@ iwl_trans_determine_restart_mode(struct iwl_trans *trans)
 	}
 
 	if (trans->restart.during_reset)
-		at_least = IWL_RESET_MODE_REPROBE;
+		min_mode = IWL_RESET_MODE_REPROBE;
 
 	data = iwl_trans_get_restart_data(trans->dev);
 	if (!data)
-		return at_least;
+		return min_mode;
 
 	if (!data->backoff &&
 	    ktime_get_boottime_seconds() - data->last_error >=
@@ -194,7 +194,7 @@ iwl_trans_determine_restart_mode(struct iwl_trans *trans)
 		data->backoff = false;
 	}
 
-	return max(at_least, escalation_list[index]);
+	return max(min_mode, escalation_list[index]);
 }
 
 #define IWL_TRANS_TOP_FOLLOWER_WAIT	180 /* ms */
-- 
2.52.0

[PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Jason A. Donenfeld]

Clang and recent gcc support warning if they are able to prove that the
user is passing to a function an array that is too short in size. For
example:

    void blah(unsigned char herp[at_least 7]);
    static void schma(void)
    {
        unsigned char good[] = { 1, 2, 3, 4, 5, 6, 7 };
        unsigned char bad[] = { 1, 2, 3, 4, 5, 6 };
        blah(good);
        blah(bad);
    }

The notation here, `static 7`, which this commit makes explicit by
allowing us to write it as `at_least 7`, means that it's incorrect to
pass anything less than 7 elements. This is section 6.7.5.3 of C99:

    If the keyword static also appears within the [ and ] of the array
    type derivation, then for each call to the function, the value of
    the corresponding actual argument shall provide access to the first
    element of an array with at least as many elements as specified by
    the size expression.

Here is the output from gcc 15:

    zx2c4@thinkpad /tmp $ gcc -c a.c
    a.c: In function ‘schma’:
    a.c:9:9: warning: ‘blah’ accessing 7 bytes in a region of size 6 [-Wstringop-overflow=]
        9 |         blah(bad);
          |         ^~~~~~~~~
    a.c:9:9: note: referencing argument 1 of type ‘unsigned char[7]’
    a.c:2:6: note: in a call to function ‘blah’
        2 | void blah(unsigned char herp[at_least 7]);
          |      ^~~~

And from clang 21:

    zx2c4@thinkpad /tmp $ clang -c a.c
    a.c:9:2: warning: array argument is too small; contains 6 elements, callee requires at least 7
          [-Warray-bounds]
        9 |         blah(bad);
          |         ^    ~~~
    a.c:2:25: note: callee declares array parameter as static here
        2 | void blah(unsigned char herp[at_least 7]);
          |                         ^   ~~~~~~~~~~
    1 warning generated.

So these are covered by, variously, -Wstringop-overflow and
-Warray-bounds.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 include/linux/compiler.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 5b45ea7dff3e..cbd3b466fdb9 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -379,6 +379,17 @@ static inline void *offset_to_ptr(const int *off)
  */
 #define prevent_tail_call_optimization()	mb()
 
+/*
+ * This designates the minimum number of elements a passed array parameter must
+ * have. For example:
+ *
+ *     void some_function(u8 param[at_least 7]);
+ * 
+ * If a caller passes an array with fewer than 7 elements, the compiler will
+ * emit a warning.
+ */
+#define at_least static
+
 #include <asm/rwonce.h>
 
 #endif /* __LINUX_COMPILER_H */
-- 
2.52.0

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Ard Biesheuvel]

On Thu, 20 Nov 2025 at 02:11, Jason A. Donenfeld <Jason@zx2c4.com> wrote:
>
> Clang and recent gcc support warning if they are able to prove that the
> user is passing to a function an array that is too short in size. For
> example:
>
>     void blah(unsigned char herp[at_least 7]);
>     static void schma(void)
>     {
>         unsigned char good[] = { 1, 2, 3, 4, 5, 6, 7 };
>         unsigned char bad[] = { 1, 2, 3, 4, 5, 6 };
>         blah(good);
>         blah(bad);
>     }
>
> The notation here, `static 7`, which this commit makes explicit by
> allowing us to write it as `at_least 7`, means that it's incorrect to
> pass anything less than 7 elements. This is section 6.7.5.3 of C99:
>
>     If the keyword static also appears within the [ and ] of the array
>     type derivation, then for each call to the function, the value of
>     the corresponding actual argument shall provide access to the first
>     element of an array with at least as many elements as specified by
>     the size expression.
>
> Here is the output from gcc 15:
>
>     zx2c4@thinkpad /tmp $ gcc -c a.c
>     a.c: In function ‘schma’:
>     a.c:9:9: warning: ‘blah’ accessing 7 bytes in a region of size 6 [-Wstringop-overflow=]
>         9 |         blah(bad);
>           |         ^~~~~~~~~
>     a.c:9:9: note: referencing argument 1 of type ‘unsigned char[7]’
>     a.c:2:6: note: in a call to function ‘blah’
>         2 | void blah(unsigned char herp[at_least 7]);
>           |      ^~~~
>
> And from clang 21:
>
>     zx2c4@thinkpad /tmp $ clang -c a.c
>     a.c:9:2: warning: array argument is too small; contains 6 elements, callee requires at least 7
>           [-Warray-bounds]
>         9 |         blah(bad);
>           |         ^    ~~~
>     a.c:2:25: note: callee declares array parameter as static here
>         2 | void blah(unsigned char herp[at_least 7]);
>           |                         ^   ~~~~~~~~~~
>     1 warning generated.
>
> So these are covered by, variously, -Wstringop-overflow and
> -Warray-bounds.
>
> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
> ---
>  include/linux/compiler.h | 11 +++++++++++
>  1 file changed, 11 insertions(+)
>

Acked-by: Ard Biesheuvel <ardb@kernel.org>

> diff --git a/include/linux/compiler.h b/include/linux/compiler.h
> index 5b45ea7dff3e..cbd3b466fdb9 100644
> --- a/include/linux/compiler.h
> +++ b/include/linux/compiler.h
> @@ -379,6 +379,17 @@ static inline void *offset_to_ptr(const int *off)
>   */
>  #define prevent_tail_call_optimization()       mb()
>
> +/*
> + * This designates the minimum number of elements a passed array parameter must
> + * have. For example:
> + *
> + *     void some_function(u8 param[at_least 7]);
> + *
> + * If a caller passes an array with fewer than 7 elements, the compiler will
> + * emit a warning.
> + */
> +#define at_least static
> +
>  #include <asm/rwonce.h>
>
>  #endif /* __LINUX_COMPILER_H */
> --
> 2.52.0
>

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Herbert Xu]

Jason A. Donenfeld <Jason@zx2c4.com> wrote:
>
> +/*
> + * This designates the minimum number of elements a passed array parameter must
> + * have. For example:
> + *
> + *     void some_function(u8 param[at_least 7]);
> + * 
> + * If a caller passes an array with fewer than 7 elements, the compiler will
> + * emit a warning.
> + */
> +#define at_least static

Please make this conditional on __CHECKER__ as sparse still chokes
on the following which compiles fine with gcc and clang:

int foo(int n, int a[static n])
{
	return a[0]++;
}

Thanks,
-- 
Email: Herbert Xu <herbert@gondor.apana.org.au>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Jason A. Donenfeld]

On Sat, Nov 22, 2025 at 3:45 AM Herbert Xu <herbert@gondor.apana.org.au> wrote:
>
> Jason A. Donenfeld <Jason@zx2c4.com> wrote:
> >
> > +/*
> > + * This designates the minimum number of elements a passed array parameter must
> > + * have. For example:
> > + *
> > + *     void some_function(u8 param[at_least 7]);
> > + *
> > + * If a caller passes an array with fewer than 7 elements, the compiler will
> > + * emit a warning.
> > + */
> > +#define at_least static
>
> Please make this conditional on __CHECKER__ as sparse still chokes
> on the following which compiles fine with gcc and clang:
>
> int foo(int n, int a[static n])
> {
>         return a[0]++;
> }

Saw your reply to v1 and was thinking about that. Will do. Thanks for
pointing this out.

Jason

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Herbert Xu]

On Sat, Nov 22, 2025 at 03:46:38AM +0100, Jason A. Donenfeld wrote:
>
> Saw your reply to v1 and was thinking about that. Will do. Thanks for
> pointing this out.

It seems that we need to bring the brackets back, because sparse
won't take this either:

int foo(int n, int a[n])
{
	return a[0]++;
}

But this seems to work:

#ifdef __CHECKER__
#define at_least(x)
#else
#define at_least(x) static x
#endif

int foo(int n, int a[at_least(n)])
{
	return a[0]++;
}

Thanks,
-- 
Email: Herbert Xu <herbert@gondor.apana.org.au>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Ard Biesheuvel]

On Sat, 22 Nov 2025 at 04:08, Herbert Xu <herbert@gondor.apana.org.au> wrote:
>
> On Sat, Nov 22, 2025 at 03:46:38AM +0100, Jason A. Donenfeld wrote:
> >
> > Saw your reply to v1 and was thinking about that. Will do. Thanks for
> > pointing this out.
>
> It seems that we need to bring the brackets back, because sparse
> won't take this either:
>
> int foo(int n, int a[n])
> {
>         return a[0]++;
> }
>
> But this seems to work:
>
> #ifdef __CHECKER__
> #define at_least(x)
> #else
> #define at_least(x) static x
> #endif
>
> int foo(int n, int a[at_least(n)])
> {
>         return a[0]++;
> }
>

This is a different idiom: n is a function argument, not a compile
time constant.

Clang and GCC both appear to permit it, but only GCC [11 or newer]
emits a diagnostic when 'n' exceeds the size of a[]. There is also
work ongoing to support the counted_by variable attribute for formal
function parameters in both compilers.

So for the moment, I think we should limit this to compile time
constants only, in which case sparse is happy too, right?

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Jason A. Donenfeld]

On Sat, Nov 22, 2025 at 12:53:58PM +0100, Ard Biesheuvel wrote:
> On Sat, 22 Nov 2025 at 04:08, Herbert Xu <herbert@gondor.apana.org.au> wrote:
> >
> > On Sat, Nov 22, 2025 at 03:46:38AM +0100, Jason A. Donenfeld wrote:
> > >
> > > Saw your reply to v1 and was thinking about that. Will do. Thanks for
> > > pointing this out.
> >
> > It seems that we need to bring the brackets back, because sparse
> > won't take this either:
> >
> > int foo(int n, int a[n])
> > {
> >         return a[0]++;
> > }
> >
> > But this seems to work:
> >
> > #ifdef __CHECKER__
> > #define at_least(x)
> > #else
> > #define at_least(x) static x
> > #endif
> >
> > int foo(int n, int a[at_least(n)])
> > {
> >         return a[0]++;
> > }
> >
> 
> This is a different idiom: n is a function argument, not a compile
> time constant.
> 
> Clang and GCC both appear to permit it, but only GCC [11 or newer]
> emits a diagnostic when 'n' exceeds the size of a[]. There is also
> work ongoing to support the counted_by variable attribute for formal
> function parameters in both compilers.
> 
> So for the moment, I think we should limit this to compile time
> constants only, in which case sparse is happy too, right?

Sparse seems happy with my v3 for constants:
https://lore.kernel.org/all/20251122025510.1625066-4-Jason@zx2c4.com/

For this new idiom -- function arguments -- I think I'll look into just
fixing sparse. This seems like something useful down the line.

So I think we ought to merge v3 as-is, and then take the longer but
better road for this additional feature Herbert has brought up, by
extending sparse.

Jason

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Eric Biggers]

On Thu, Nov 20, 2025 at 02:10:21AM +0100, Jason A. Donenfeld wrote:
> Clang and recent gcc support warning if they are able to prove that the
> user is passing to a function an array that is too short in size. For
> example:

(Replying to this patch since there is no cover letter.  In the future,
please include a cover letter when sending a multi-patch series.)

I've applied this series to
https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/linux.git/log/?h=libcrypto-next

In case it gets bikeshedded further, I merged it in on a separate
branch, and I'll plan to send it in its own pull request.

Thanks!

- Eric

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Eric Biggers]

On Sat, Nov 22, 2025 at 11:19:12AM -0800, Eric Biggers wrote:
> On Thu, Nov 20, 2025 at 02:10:21AM +0100, Jason A. Donenfeld wrote:
> > Clang and recent gcc support warning if they are able to prove that the
> > user is passing to a function an array that is too short in size. For
> > example:
> 
> (Replying to this patch since there is no cover letter.  In the future,
> please include a cover letter when sending a multi-patch series.)
> 
> I've applied this series to
> https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/linux.git/log/?h=libcrypto-next
> 
> In case it gets bikeshedded further, I merged it in on a separate
> branch, and I'll plan to send it in its own pull request.

Sorry, wrong version.  Fixed now; I replaced it with v3.

- Eric

Re: [PATCH libcrypto v2 2/3] compiler: introduce at_least parameter decoration pseudo keyword

[Jason A. Donenfeld]

On Sat, Nov 22, 2025 at 11:19:12AM -0800, Eric Biggers wrote:
> On Thu, Nov 20, 2025 at 02:10:21AM +0100, Jason A. Donenfeld wrote:
> > Clang and recent gcc support warning if they are able to prove that the
> > user is passing to a function an array that is too short in size. For
> > example:
> 
> (Replying to this patch since there is no cover letter.  In the future,
> please include a cover letter when sending a multi-patch series.)

Ah, sorry, I saw this after sending v4 yesterday. Will do in the future.

Jason

[PATCH libcrypto v2 3/3] crypto: chacha20poly1305: statically check fixed array lengths

[Jason A. Donenfeld]

Several parameters of the chacha20poly1305 functions require arrays of
an exact length. Use the new at_least keyword to instruct gcc and
clang to statically check that the caller is passing an object of at
least that length.

Here it is in action, with this faulty patch to wireguard's cookie.h:

     struct cookie_checker {
     	u8 secret[NOISE_HASH_LEN];
    -	u8 cookie_encryption_key[NOISE_SYMMETRIC_KEY_LEN];
    +	u8 cookie_encryption_key[NOISE_SYMMETRIC_KEY_LEN - 1];
     	u8 message_mac1_key[NOISE_SYMMETRIC_KEY_LEN];

If I try compiling this code, I get this helpful warning:

  CC      drivers/net/wireguard/cookie.o
drivers/net/wireguard/cookie.c: In function ‘wg_cookie_message_create’:
drivers/net/wireguard/cookie.c:193:9: warning: ‘xchacha20poly1305_encrypt’ reading 32 bytes from a region of size 31 [-Wstringop-overread]
  193 |         xchacha20poly1305_encrypt(dst->encrypted_cookie, cookie, COOKIE_LEN,
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  194 |                                   macs->mac1, COOKIE_LEN, dst->nonce,
      |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  195 |                                   checker->cookie_encryption_key);
      |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/net/wireguard/cookie.c:193:9: note: referencing argument 7 of type ‘const u8 *’ {aka ‘const unsigned char *’}
In file included from drivers/net/wireguard/messages.h:10,
                 from drivers/net/wireguard/cookie.h:9,
                 from drivers/net/wireguard/cookie.c:6:
include/crypto/chacha20poly1305.h:28:6: note: in a call to function ‘xchacha20poly1305_encrypt’
   28 | void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 include/crypto/chacha20poly1305.h | 16 ++++++++--------
 lib/crypto/chacha20poly1305.c     | 18 +++++++++---------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/include/crypto/chacha20poly1305.h b/include/crypto/chacha20poly1305.h
index d2ac3ff7dc1e..7617366f8218 100644
--- a/include/crypto/chacha20poly1305.h
+++ b/include/crypto/chacha20poly1305.h
@@ -18,32 +18,32 @@ enum chacha20poly1305_lengths {
 void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
 			      const u8 *ad, const size_t ad_len,
 			      const u64 nonce,
-			      const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+			      const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 bool __must_check
 chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
 			 const u8 *ad, const size_t ad_len, const u64 nonce,
-			 const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+			 const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
 			       const u8 *ad, const size_t ad_len,
-			       const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
-			       const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+			       const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
+			       const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 bool __must_check xchacha20poly1305_decrypt(
 	u8 *dst, const u8 *src, const size_t src_len, const u8 *ad,
-	const size_t ad_len, const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
-	const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+	const size_t ad_len, const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
+	const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 bool chacha20poly1305_encrypt_sg_inplace(struct scatterlist *src, size_t src_len,
 					 const u8 *ad, const size_t ad_len,
 					 const u64 nonce,
-					 const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+					 const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len,
 					 const u8 *ad, const size_t ad_len,
 					 const u64 nonce,
-					 const u8 key[CHACHA20POLY1305_KEY_SIZE]);
+					 const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
 bool chacha20poly1305_selftest(void);
 
diff --git a/lib/crypto/chacha20poly1305.c b/lib/crypto/chacha20poly1305.c
index 0b49d6aedefd..212ce33562af 100644
--- a/lib/crypto/chacha20poly1305.c
+++ b/lib/crypto/chacha20poly1305.c
@@ -89,7 +89,7 @@ __chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
 void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
 			      const u8 *ad, const size_t ad_len,
 			      const u64 nonce,
-			      const u8 key[CHACHA20POLY1305_KEY_SIZE])
+			      const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	struct chacha_state chacha_state;
 	u32 k[CHACHA_KEY_WORDS];
@@ -111,8 +111,8 @@ EXPORT_SYMBOL(chacha20poly1305_encrypt);
 
 void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
 			       const u8 *ad, const size_t ad_len,
-			       const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
-			       const u8 key[CHACHA20POLY1305_KEY_SIZE])
+			       const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
+			       const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	struct chacha_state chacha_state;
 
@@ -170,7 +170,7 @@ __chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
 bool chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
 			      const u8 *ad, const size_t ad_len,
 			      const u64 nonce,
-			      const u8 key[CHACHA20POLY1305_KEY_SIZE])
+			      const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	struct chacha_state chacha_state;
 	u32 k[CHACHA_KEY_WORDS];
@@ -195,8 +195,8 @@ EXPORT_SYMBOL(chacha20poly1305_decrypt);
 
 bool xchacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
 			       const u8 *ad, const size_t ad_len,
-			       const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
-			       const u8 key[CHACHA20POLY1305_KEY_SIZE])
+			       const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
+			       const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	struct chacha_state chacha_state;
 
@@ -211,7 +211,7 @@ bool chacha20poly1305_crypt_sg_inplace(struct scatterlist *src,
 				       const size_t src_len,
 				       const u8 *ad, const size_t ad_len,
 				       const u64 nonce,
-				       const u8 key[CHACHA20POLY1305_KEY_SIZE],
+				       const u8 key[at_least CHACHA20POLY1305_KEY_SIZE],
 				       int encrypt)
 {
 	const u8 *pad0 = page_address(ZERO_PAGE(0));
@@ -335,7 +335,7 @@ bool chacha20poly1305_crypt_sg_inplace(struct scatterlist *src,
 bool chacha20poly1305_encrypt_sg_inplace(struct scatterlist *src, size_t src_len,
 					 const u8 *ad, const size_t ad_len,
 					 const u64 nonce,
-					 const u8 key[CHACHA20POLY1305_KEY_SIZE])
+					 const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	return chacha20poly1305_crypt_sg_inplace(src, src_len, ad, ad_len,
 						 nonce, key, 1);
@@ -345,7 +345,7 @@ EXPORT_SYMBOL(chacha20poly1305_encrypt_sg_inplace);
 bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len,
 					 const u8 *ad, const size_t ad_len,
 					 const u64 nonce,
-					 const u8 key[CHACHA20POLY1305_KEY_SIZE])
+					 const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
 {
 	if (unlikely(src_len < POLY1305_DIGEST_SIZE))
 		return false;
-- 
2.52.0

Re: [PATCH libcrypto v2 3/3] crypto: chacha20poly1305: statically check fixed array lengths

[Ard Biesheuvel]

On Thu, 20 Nov 2025 at 02:11, Jason A. Donenfeld <Jason@zx2c4.com> wrote:
>
> Several parameters of the chacha20poly1305 functions require arrays of
> an exact length. Use the new at_least keyword to instruct gcc and
> clang to statically check that the caller is passing an object of at
> least that length.
>
> Here it is in action, with this faulty patch to wireguard's cookie.h:
>
>      struct cookie_checker {
>         u8 secret[NOISE_HASH_LEN];
>     -   u8 cookie_encryption_key[NOISE_SYMMETRIC_KEY_LEN];
>     +   u8 cookie_encryption_key[NOISE_SYMMETRIC_KEY_LEN - 1];
>         u8 message_mac1_key[NOISE_SYMMETRIC_KEY_LEN];
>
> If I try compiling this code, I get this helpful warning:
>
>   CC      drivers/net/wireguard/cookie.o
> drivers/net/wireguard/cookie.c: In function ‘wg_cookie_message_create’:
> drivers/net/wireguard/cookie.c:193:9: warning: ‘xchacha20poly1305_encrypt’ reading 32 bytes from a region of size 31 [-Wstringop-overread]
>   193 |         xchacha20poly1305_encrypt(dst->encrypted_cookie, cookie, COOKIE_LEN,
>       |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>   194 |                                   macs->mac1, COOKIE_LEN, dst->nonce,
>       |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>   195 |                                   checker->cookie_encryption_key);
>       |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> drivers/net/wireguard/cookie.c:193:9: note: referencing argument 7 of type ‘const u8 *’ {aka ‘const unsigned char *’}
> In file included from drivers/net/wireguard/messages.h:10,
>                  from drivers/net/wireguard/cookie.h:9,
>                  from drivers/net/wireguard/cookie.c:6:
> include/crypto/chacha20poly1305.h:28:6: note: in a call to function ‘xchacha20poly1305_encrypt’
>    28 | void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>
> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
> ---
>  include/crypto/chacha20poly1305.h | 16 ++++++++--------
>  lib/crypto/chacha20poly1305.c     | 18 +++++++++---------
>  2 files changed, 17 insertions(+), 17 deletions(-)
>

Acked-by: Ard Biesheuvel <ardb@kernel.org>

> diff --git a/include/crypto/chacha20poly1305.h b/include/crypto/chacha20poly1305.h
> index d2ac3ff7dc1e..7617366f8218 100644
> --- a/include/crypto/chacha20poly1305.h
> +++ b/include/crypto/chacha20poly1305.h
> @@ -18,32 +18,32 @@ enum chacha20poly1305_lengths {
>  void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>                               const u8 *ad, const size_t ad_len,
>                               const u64 nonce,
> -                             const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +                             const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  bool __must_check
>  chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
>                          const u8 *ad, const size_t ad_len, const u64 nonce,
> -                        const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +                        const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>                                const u8 *ad, const size_t ad_len,
> -                              const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
> -                              const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +                              const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
> +                              const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  bool __must_check xchacha20poly1305_decrypt(
>         u8 *dst, const u8 *src, const size_t src_len, const u8 *ad,
> -       const size_t ad_len, const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
> -       const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +       const size_t ad_len, const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
> +       const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  bool chacha20poly1305_encrypt_sg_inplace(struct scatterlist *src, size_t src_len,
>                                          const u8 *ad, const size_t ad_len,
>                                          const u64 nonce,
> -                                        const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +                                        const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len,
>                                          const u8 *ad, const size_t ad_len,
>                                          const u64 nonce,
> -                                        const u8 key[CHACHA20POLY1305_KEY_SIZE]);
> +                                        const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
>
>  bool chacha20poly1305_selftest(void);
>
> diff --git a/lib/crypto/chacha20poly1305.c b/lib/crypto/chacha20poly1305.c
> index 0b49d6aedefd..212ce33562af 100644
> --- a/lib/crypto/chacha20poly1305.c
> +++ b/lib/crypto/chacha20poly1305.c
> @@ -89,7 +89,7 @@ __chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>  void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>                               const u8 *ad, const size_t ad_len,
>                               const u64 nonce,
> -                             const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                             const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         struct chacha_state chacha_state;
>         u32 k[CHACHA_KEY_WORDS];
> @@ -111,8 +111,8 @@ EXPORT_SYMBOL(chacha20poly1305_encrypt);
>
>  void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,
>                                const u8 *ad, const size_t ad_len,
> -                              const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
> -                              const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                              const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
> +                              const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         struct chacha_state chacha_state;
>
> @@ -170,7 +170,7 @@ __chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
>  bool chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
>                               const u8 *ad, const size_t ad_len,
>                               const u64 nonce,
> -                             const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                             const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         struct chacha_state chacha_state;
>         u32 k[CHACHA_KEY_WORDS];
> @@ -195,8 +195,8 @@ EXPORT_SYMBOL(chacha20poly1305_decrypt);
>
>  bool xchacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,
>                                const u8 *ad, const size_t ad_len,
> -                              const u8 nonce[XCHACHA20POLY1305_NONCE_SIZE],
> -                              const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                              const u8 nonce[at_least XCHACHA20POLY1305_NONCE_SIZE],
> +                              const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         struct chacha_state chacha_state;
>
> @@ -211,7 +211,7 @@ bool chacha20poly1305_crypt_sg_inplace(struct scatterlist *src,
>                                        const size_t src_len,
>                                        const u8 *ad, const size_t ad_len,
>                                        const u64 nonce,
> -                                      const u8 key[CHACHA20POLY1305_KEY_SIZE],
> +                                      const u8 key[at_least CHACHA20POLY1305_KEY_SIZE],
>                                        int encrypt)
>  {
>         const u8 *pad0 = page_address(ZERO_PAGE(0));
> @@ -335,7 +335,7 @@ bool chacha20poly1305_crypt_sg_inplace(struct scatterlist *src,
>  bool chacha20poly1305_encrypt_sg_inplace(struct scatterlist *src, size_t src_len,
>                                          const u8 *ad, const size_t ad_len,
>                                          const u64 nonce,
> -                                        const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                                        const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         return chacha20poly1305_crypt_sg_inplace(src, src_len, ad, ad_len,
>                                                  nonce, key, 1);
> @@ -345,7 +345,7 @@ EXPORT_SYMBOL(chacha20poly1305_encrypt_sg_inplace);
>  bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len,
>                                          const u8 *ad, const size_t ad_len,
>                                          const u64 nonce,
> -                                        const u8 key[CHACHA20POLY1305_KEY_SIZE])
> +                                        const u8 key[at_least CHACHA20POLY1305_KEY_SIZE])
>  {
>         if (unlikely(src_len < POLY1305_DIGEST_SIZE))
>                 return false;
> --
> 2.52.0
>

Re: [PATCH libcrypto v2 1/3] wifi: iwlwifi: trans: rename at_least variable to min_mode

[Ard Biesheuvel]

(cc linux-wireless)

On Thu, 20 Nov 2025 at 02:11, Jason A. Donenfeld <Jason@zx2c4.com> wrote:
>
> The subsequent commit is going to add a macro that redefines `at_least`
> to mean something else. Given that the usage here in iwlwifi is the only
> use of that identifier in the whole kernel, just rename it to a more
> fitting name, `min_mode`.
>
> Cc: Miri Korenblit <miriam.rachel.korenblit@intel.com>
> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

Acked-by: Ard Biesheuvel <ardb@kernel.org>

> ---
>  drivers/net/wireless/intel/iwlwifi/iwl-trans.c | 8 ++++----
>  1 file changed, 4 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
> index 5232f66c2d52..cc8a84018f70 100644
> --- a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
> +++ b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
> @@ -129,7 +129,7 @@ static enum iwl_reset_mode
>  iwl_trans_determine_restart_mode(struct iwl_trans *trans)
>  {
>         struct iwl_trans_dev_restart_data *data;
> -       enum iwl_reset_mode at_least = 0;
> +       enum iwl_reset_mode min_mode = 0;
>         unsigned int index;
>         static const enum iwl_reset_mode escalation_list_old[] = {
>                 IWL_RESET_MODE_SW_RESET,
> @@ -173,11 +173,11 @@ iwl_trans_determine_restart_mode(struct iwl_trans *trans)
>         }
>
>         if (trans->restart.during_reset)
> -               at_least = IWL_RESET_MODE_REPROBE;
> +               min_mode = IWL_RESET_MODE_REPROBE;
>
>         data = iwl_trans_get_restart_data(trans->dev);
>         if (!data)
> -               return at_least;
> +               return min_mode;
>
>         if (!data->backoff &&
>             ktime_get_boottime_seconds() - data->last_error >=
> @@ -194,7 +194,7 @@ iwl_trans_determine_restart_mode(struct iwl_trans *trans)
>                 data->backoff = false;
>         }
>
> -       return max(at_least, escalation_list[index]);
> +       return max(min_mode, escalation_list[index]);
>  }
>
>  #define IWL_TRANS_TOP_FOLLOWER_WAIT    180 /* ms */
> --
> 2.52.0
>