Commit c3d7ab5500 for openssl.org

commit c3d7ab55001030868eda69000b0f1c3967d220b5
Author: Filip Skokan <panva.ip@gmail.com>
Date:   Thu Apr 30 08:02:54 2026 +0200

    Add support for RFC 9861 TurboSHAKE and KangarooTwelve XOF digests

    Add default-provider EVP digest implementations for RFC 9861
    TURBOSHAKE-128, TURBOSHAKE-256, KT-128, and KT-256.

    Fixes #30304

    Assisted-by: Codex
    Signed-off-by: Filip Skokan <panva.ip@gmail.com>
    Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
    Reviewed-by: Milan Broz <mbroz@openssl.org>
    Merge-date: Mon Nov 16 02:00:19 2026
    Merged-from: https://github.com/openssl/openssl/pull/31027

diff --git a/.gitignore b/.gitignore
index 4d084af649..2922d0b425 100644
--- a/.gitignore
+++ b/.gitignore
@@ -188,6 +188,8 @@ providers/implementations/digests/sha2_prov.inc
 providers/implementations/digests/sha3_prov.inc
 providers/implementations/digests/ml_dsa_mu_prov.inc
 providers/implementations/digests/cshake_prov.inc
+providers/implementations/digests/kt_prov.inc
+providers/implementations/digests/turboshake_prov.inc
 providers/implementations/include/prov/blake2_params.inc
 providers/implementations/macs/cmac_prov.inc
 providers/implementations/macs/gmac_prov.inc
diff --git a/CHANGES.md b/CHANGES.md
index 54279dfc0a..8cac4bde01 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -33,6 +33,10 @@ OpenSSL 4.2

 ### Changes between 4.1 and 4.2 [xx XXX xxxx]

+ * Added TurboSHAKE and KangarooTwelve XOF digest support as per [RFC 9861].
+
+   *Filip Skokan*
+
  * Added `CRYPTO_new_ex_data_ex()`, an `OSSL_LIB_CTX`-aware variant of
    `CRYPTO_new_ex_data()`.

@@ -24698,6 +24702,7 @@ ndif
 [RFC 9846]: https://datatracker.ietf.org/doc/html/rfc9846
 [RFC 9846 Section 4.3.10]: https://datatracker.ietf.org/doc/html/rfc9846#section-4.3.10
 [RFC 9849]: https://datatracker.ietf.org/doc/html/rfc9849
+[RFC 9861]: https://datatracker.ietf.org/doc/html/rfc9861
 [SECG SEC 1 Section 2.3.4]: https://www.secg.org/sec1-v2.pdf#subsubsection.2.3.4
 [SP 800-132]: https://csrc.nist.gov/pubs/sp/800/132/final
 [SP 800-185]: https://csrc.nist.gov/pubs/sp/800/185/final
diff --git a/Configure b/Configure
index 7273534c78..63c98246d6 100755
--- a/Configure
+++ b/Configure
@@ -471,6 +471,7 @@ my @disablables_algorithms = (
     "ecx",
     "kbkdf",
     "krb5kdf",
+    "kt",
     "gost",
     "idea",
     "ikev2kdf",
@@ -501,6 +502,7 @@ my @disablables_algorithms = (
     "srtpkdf",
     "sshkdf",
     "sskdf",
+    "turboshake",
     "x942kdf",
     "x963kdf",
     "whirlpool",
@@ -678,7 +680,7 @@ my @disable_cascades = (
                              "des", "dgram", "dh", "dsa",
                              "ec", "ech",
                              "filenames", "hmac-drbg-kdf",
-                             "idea", "ikev2kdf", "kbkdf", "krb5kdf", "ktls", "lms",
+                             "idea", "ikev2kdf", "kbkdf", "krb5kdf", "kt", "ktls", "lms",
                              "md4", "ml-dsa", "ml-kem", "multiblock",
                              "nextprotoneg", "ocsp", "ocb", "poly1305", "psk",
                              "pvkkdf", "rc2", "rc4", "rmd160",
@@ -687,7 +689,7 @@ my @disable_cascades = (
                              "srp", "srtp", "srtpkdf", "sshkdf", "sskdf",
                              "ssl-trace",
                              "tfo",
-                             "ts", "ui-console", "whirlpool",
+                             "ts", "turboshake", "ui-console", "whirlpool",
                              "x942kdf", "x963kdf",
                              "fips-securitychecks" ],
     sub { $config{processor} eq "386" }
@@ -749,6 +751,7 @@ my @disable_cascades = (
     "thread-pool"       => [ "default-thread-pool" ],

     "blake2"            => [ "argon2" ],
+    "turboshake"        => [ "kt" ],

     "deprecated-3.0"    => [ "srp" ],

diff --git a/INSTALL.md b/INSTALL.md
index 6e00f2ae15..da29c55727 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1222,15 +1222,18 @@ The `lms` algorithm support is currently limited to verification only as per

     no-{aria|bf|blake2|camellia|cast|chacha|cmac|
         des|dh|dsa|
-        ec|ec2m|ecdh|ecdsa|hmac-drbg-kdf|idea|ikev2kdf|kbkdf|krb5kdf|
+        ec|ec2m|ecdh|ecdsa|hmac-drbg-kdf|idea|ikev2kdf|kbkdf|krb5kdf|kt|
         md4|mdc2|
         ml-dsa|ml-kem|
         ocb|poly1305|pvkkdf|rc2|rc4|rmd160|scrypt|
         seed|siphash|siv|slh-dsa|sm2|sm3|sm4|snmpkdf|srtpkdf|sshkdf|sskdf|
-        x942kdf|x963kdf|whirlpool}
+        turboshake|x942kdf|x963kdf|whirlpool}

 Build without support for the specified algorithm.

+Disabling `turboshake` also disables `kt`, which depends on the TurboSHAKE
+implementation. Disabling `kt` does not disable TurboSHAKE.
+
 The `ripemd` algorithm is deprecated and if used is synonymous with `rmd160`.

 Compiler-specific options
diff --git a/NEWS.md b/NEWS.md
index 2039e1b19c..583035b593 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -29,6 +29,8 @@ OpenSSL 4.2

 ### Major changes between OpenSSL 4.1 and OpenSSL 4.2 [under development]

+  * TurboSHAKE and KangarooTwelve XOF digest support as per [RFC 9861].
+
   * Added support for Java keytool PKCS#12 files with symmetric keys.
     New API `PKCS12_parse_ex()` with `PKCS12_PARSE_CTX` has been added.

@@ -2687,6 +2689,7 @@ OpenSSL 0.9.x
 [RFC 8998]: https://datatracker.ietf.org/doc/html/rfc8998#name-iana-considerations
 [RFC 9147]: https://datatracker.ietf.org/doc/html/rfc9147
 [RFC 9849]: https://datatracker.ietf.org/doc/html/rfc9849
+[RFC 9861]: https://datatracker.ietf.org/doc/html/rfc9861
 [SP 800-185]: https://csrc.nist.gov/pubs/sp/800/185/final
 [SP 800-208]: https://csrc.nist.gov/pubs/sp/800/208/final
 [issue tracker]: https://github.com/openssl/openssl/issues
diff --git a/build.info b/build.info
index eedc3c4d71..6a103d53af 100644
--- a/build.info
+++ b/build.info
@@ -169,6 +169,8 @@ DEPEND[]=include/openssl/asn1.h \
          providers/implementations/digests/sha3_prov.inc \
          providers/implementations/digests/ml_dsa_mu_prov.inc \
          providers/implementations/digests/cshake_prov.inc \
+         providers/implementations/digests/turboshake_prov.inc \
+         providers/implementations/digests/kt_prov.inc \
          providers/implementations/include/prov/blake2_params.inc \
          providers/implementations/macs/cmac_prov.inc \
          providers/implementations/macs/gmac_prov.inc \
@@ -312,6 +314,8 @@ DEPEND[ssl/t1_lib.inc \
        providers/implementations/digests/sha2_prov.inc \
        providers/implementations/digests/sha3_prov.inc \
        providers/implementations/digests/cshake_prov.inc \
+       providers/implementations/digests/turboshake_prov.inc \
+       providers/implementations/digests/kt_prov.inc \
        providers/implementations/include/prov/blake2_params.inc \
        providers/implementations/macs/cmac_prov.inc \
        providers/implementations/macs/gmac_prov.inc \
@@ -509,6 +513,10 @@ GENERATE[providers/implementations/digests/sha3_prov.inc]=\
     providers/implementations/digests/sha3_prov.inc.in
 GENERATE[providers/implementations/digests/cshake_prov.inc]=\
     providers/implementations/digests/cshake_prov.inc.in
+GENERATE[providers/implementations/digests/turboshake_prov.inc]=\
+    providers/implementations/digests/turboshake_prov.inc.in
+GENERATE[providers/implementations/digests/kt_prov.inc]=\
+    providers/implementations/digests/kt_prov.inc.in
 GENERATE[providers/implementations/include/prov/blake2_params.inc]=\
     providers/implementations/include/prov/blake2_params.inc.in
 GENERATE[providers/implementations/digests/ml_dsa_mu_prov.inc]=\
diff --git a/crypto/sha/asm/keccak1600-armv4.pl b/crypto/sha/asm/keccak1600-armv4.pl
index 6414ef5cfe..59c1155014 100755
--- a/crypto/sha/asm/keccak1600-armv4.pl
+++ b/crypto/sha/asm/keccak1600-armv4.pl
@@ -70,6 +70,10 @@
 #	Cortex-Mx, x>=3. Otherwise, non-NEON results for NEON-capable
 #	processors are presented mostly for reference purposes.

+use FindBin qw($Bin);
+use lib "$Bin";
+require "keccak1600-common.pl";
+
 # $output is the last argument if it looks like a file (it has an extension)
 # $flavour is the first argument if it doesn't look like a file
 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
@@ -166,6 +170,18 @@ KeccakF1600_enter:
 	str	@E[1],[sp,#444]
 	b	.Lround2x

+.type	KeccakP1600_12_int, %function
+KeccakP1600_12_int:
+	add	@C[9],sp,#$A[4][2]
+	add	@E[2],sp,#$A[0][0]
+	add	@E[0],sp,#$A[1][0]
+	ldmia	@C[9],{@C[4]-@C[9]}		@ A[4][2..4]
+KeccakP1600_12_enter:
+	str	lr,[sp,#440]
+	mov	@E[1],#96
+	str	@E[1],[sp,#444]
+	b	.Lround2x
+
 .align	4
 .Lround2x:
 ___
@@ -702,7 +718,10 @@ $code.=<<___;
 	bx	lr		@ interoperable with Thumb ISA:-)
 #endif
 .size	KeccakF1600_int,.-KeccakF1600_int
+___

+my $p12_start = length($code);
+$code.=<<___;
 .type	KeccakF1600, %function
 .align	5
 KeccakF1600:
@@ -749,6 +768,11 @@ KeccakF1600:
 #endif
 .size	KeccakF1600,.-KeccakF1600
 ___
+
+my $p12 = rename_labels(substr($code, $p12_start),
+                        "KeccakF1600", "KeccakP1600_12");
+$p12 =~ s/KeccakF1600_enter/KeccakP1600_12_enter/g;
+$code .= $p12;
 { my ($A_flat,$inp,$len,$bsz) = map("r$_",(10..12,14));

 ########################################################################
@@ -776,6 +800,7 @@ ___
 # +488->+-----------------------+
 #       | ....

+$p12_start = length($code);
 $code.=<<___;
 .global	SHA3_absorb
 .type	SHA3_absorb,%function
@@ -931,6 +956,11 @@ SHA3_absorb:
 #endif
 .size	SHA3_absorb,.-SHA3_absorb
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_absorb", "ossl_keccak1600_p12_absorb");
+$p12 =~ s/KeccakF1600_int/KeccakP1600_12_int/g;
+$code .= $p12;
 }

 { my ($out,$len,$A_flat,$bsz,$next) = map("r$_", (4,5,10,12,0));
@@ -942,6 +972,7 @@ ___
 # The first 4 parameters are passed in via r0..r3,
 # next is passed on the stack [sp, #0]

+$p12_start = length($code);
 $code.=<<___;
 .global	SHA3_squeeze
 .type	SHA3_squeeze,%function
@@ -1099,6 +1130,11 @@ SHA3_squeeze:
 #endif
 .size	SHA3_squeeze,.-SHA3_squeeze
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_squeeze", "ossl_keccak1600_p12_squeeze");
+$p12 =~ s/KeccakF1600/KeccakP1600_12/g;
+$code .= $p12;
 }

 $code.=<<___;
diff --git a/crypto/sha/asm/keccak1600-armv8.pl b/crypto/sha/asm/keccak1600-armv8.pl
index 3bda2fd727..d5aa290e30 100755
--- a/crypto/sha/asm/keccak1600-armv8.pl
+++ b/crypto/sha/asm/keccak1600-armv8.pl
@@ -59,6 +59,10 @@
 #	Cortex-A57 to 25% on Cortex-A53. While in comparison to older
 #	compiler this code is at least 2x faster...

+use FindBin qw($Bin);
+use lib "$Bin";
+require "keccak1600-common.pl";
+
 # $output is the last argument if it looks like a file (it has an extension)
 # $flavour is the first argument if it doesn't look like a file
 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
@@ -133,6 +137,13 @@ KeccakF1600_int:
 	add	$C[2],$C[2],:lo12:iotas
 	stp	$C[2],x30,[sp,#16]		// 32 bytes on top are mine
 	b	.Loop
+.LKeccakP1600_12_int:
+	AARCH64_SIGN_LINK_REGISTER
+	adrp	$C[2],iotas
+	add	$C[2],$C[2],:lo12:iotas
+	add	$C[2],$C[2],#96
+	stp	$C[2],x30,[sp,#16]		// 32 bytes on top are mine
+	b	.Loop
 .align	4
 .Loop:
 	////////////////////////////////////////// Theta
@@ -305,7 +316,10 @@ $code.=<<___;
 	AARCH64_VALIDATE_LINK_REGISTER
 	ret
 .size	KeccakF1600_int,.-KeccakF1600_int
+___

+my $p12_start = length($code);
+$code.=<<___;
 .type	KeccakF1600,%function
 .align	5
 KeccakF1600:
@@ -362,6 +376,15 @@ KeccakF1600:
 	AARCH64_VALIDATE_LINK_REGISTER
 	ret
 .size	KeccakF1600,.-KeccakF1600
+___
+
+my $p12 = rename_labels(substr($code, $p12_start),
+                        "KeccakF1600", "KeccakP1600_12");
+$p12 =~ s/KeccakF1600_int/.LKeccakP1600_12_int/g;
+$code .= $p12;
+
+$p12_start = length($code);
+$code.=<<___;

 .globl	SHA3_absorb
 .type	SHA3_absorb,%function
@@ -469,8 +492,15 @@ $code.=<<___;
 	ret
 .size	SHA3_absorb,.-SHA3_absorb
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_absorb", "ossl_keccak1600_p12_absorb");
+$p12 =~ s/KeccakF1600_int/.LKeccakP1600_12_int/g;
+$code .= $p12;
+
 {
 my ($A_flat,$out,$len,$bsz) = map("x$_",(19..22));
+$p12_start = length($code);
 $code.=<<___;
 .globl	SHA3_squeeze
 .type	SHA3_squeeze,%function
@@ -545,6 +575,11 @@ SHA3_squeeze:
 	ret
 .size	SHA3_squeeze,.-SHA3_squeeze
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_squeeze", "ossl_keccak1600_p12_squeeze");
+$p12 =~ s/KeccakF1600/KeccakP1600_12/g;
+$code .= $p12;
 }								}}}
 								{{{
 my @A = map([ "v".$_.".16b", "v".($_+1).".16b", "v".($_+2).".16b",
diff --git a/crypto/sha/asm/keccak1600-common.pl b/crypto/sha/asm/keccak1600-common.pl
new file mode 100644
index 0000000000..71e857fb90
--- /dev/null
+++ b/crypto/sha/asm/keccak1600-common.pl
@@ -0,0 +1,31 @@
+#! /usr/bin/env perl
+# Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+#
+# Licensed under the Apache License 2.0 (the "License").  You may not use
+# this file except in compliance with the License.  You can obtain a copy
+# in the file LICENSE in the source distribution or at
+# https://www.openssl.org/source/license.html
+
+sub rename_labels {
+    my ($text, $from, $to) = @_;
+    my %labels;
+
+    while ($text =~ /^\s*([A-Za-z_.][A-Za-z0-9_\$.]*):/mg) {
+        my ($label, $replacement) = ($1, $1);
+
+        $replacement .= "_p12" unless $replacement =~ s/\Q$from\E/$to/g;
+        $labels{$label} = $replacement;
+    }
+
+    if (%labels) {
+        my $pattern = join("|", map { quotemeta($_) }
+                                sort { length($b) <=> length($a) }
+                                keys %labels);
+
+        $text =~ s/(?<![A-Za-z0-9_\$.])($pattern)(?![A-Za-z0-9_\$.])/$labels{$1}/g;
+    }
+
+    return $text;
+}
+
+1;
diff --git a/crypto/sha/asm/keccak1600-ppc64.pl b/crypto/sha/asm/keccak1600-ppc64.pl
index 00f52a294d..9d0fbb2494 100755
--- a/crypto/sha/asm/keccak1600-ppc64.pl
+++ b/crypto/sha/asm/keccak1600-ppc64.pl
@@ -37,6 +37,10 @@
 #	much better (but watch out for them generating code specific
 #	to processor they execute on).

+use FindBin qw($Bin);
+use lib "$Bin";
+require "keccak1600-common.pl";
+
 # $output is the last argument if it looks like a file (it has an extension)
 # $flavour is the first argument if it doesn't look like a file
 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
@@ -96,6 +100,12 @@ KeccakF1600_int:
 	li	r0,24
 	mtctr	r0
 	b	.Loop
+
+.type	KeccakP1600_12_int,\@function
+KeccakP1600_12_int:
+	li	r0,12
+	mtctr	r0
+	b	.Loop
 .align	4
 .Loop:
 	xor	$C[0],$A[0][0],$A[1][0]		; Theta
@@ -395,6 +405,13 @@ KeccakF1600:
 	.long	0
 .size	KeccakF1600,.-KeccakF1600
 ___
+
+my ($p12) = $code =~ /(^\.type\tKeccakF1600,.*?^\.size\tKeccakF1600,\.\-KeccakF1600$)/ms
+    or die "failed to duplicate KeccakF1600";
+$p12 = rename_labels($p12, "KeccakF1600", "KeccakP1600_12");
+$p12 =~ s/KeccakF1600_int/KeccakP1600_12_int/g;
+$p12 =~ s/(\tsubi\tr12,r12,8[^\n]*\n)/$1\taddi\tr12,r12,`8*12`\n/;
+$code .= "\n$p12\n";
 if (!$LITTLE_ENDIAN) {
 $code.=<<___;
 .type	dword_le_load,\@function
@@ -648,6 +665,15 @@ SHA3_absorb:
 	.long	0
 .size	SHA3_absorb,.-SHA3_absorb
 ___
+
+($p12) = $code =~ /(^\.globl\tSHA3_absorb\n.*?^\.size\tSHA3_absorb,\.\-SHA3_absorb$)/ms
+    or die "failed to duplicate SHA3_absorb";
+$p12 = rename_labels($p12, "SHA3_absorb", "ossl_keccak1600_p12_absorb");
+$p12 =~ s/KeccakF1600_int/KeccakP1600_12_int/g;
+$p12 =~ s/(\tsubi\tr12,r12,8[^\n]*\n)/$1\taddi\tr12,r12,`8*12`\n/;
+$p12 =~ s/iotas\[24\]/iotas[12]/g;
+$p12 =~ s/-8\*24/-8*12/g;
+$code .= "\n$p12\n";
 {
 my ($A_flat,$out,$len,$bsz) = map("r$_",(28..31));
 $code.=<<___;
@@ -729,6 +755,12 @@ SHA3_squeeze:
 	.long	0
 .size	SHA3_squeeze,.-SHA3_squeeze
 ___
+
+($p12) = $code =~ /(^\.globl\tSHA3_squeeze\n.*?^\.size\tSHA3_squeeze,\.\-SHA3_squeeze$)/ms
+    or die "failed to duplicate SHA3_squeeze";
+$p12 = rename_labels($p12, "SHA3_squeeze", "ossl_keccak1600_p12_squeeze");
+$p12 =~ s/KeccakF1600/KeccakP1600_12/g;
+$code .= "\n$p12\n";
 }

 # Ugly hack here, because PPC assembler syntax seem to vary too
diff --git a/crypto/sha/asm/keccak1600-s390x.pl b/crypto/sha/asm/keccak1600-s390x.pl
index fda541fbfa..5717b8623f 100755
--- a/crypto/sha/asm/keccak1600-s390x.pl
+++ b/crypto/sha/asm/keccak1600-s390x.pl
@@ -30,6 +30,10 @@
 # amount of instruction and assumed instruction issue rate. It's ~2.5x
 # faster than compiler-generated code.

+use FindBin qw($Bin);
+use lib "$Bin";
+require "keccak1600-common.pl";
+
 # $output is the last argument if it looks like a file (it has an extension)
 # $flavour is the first argument if it doesn't look like a file
 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
@@ -81,6 +85,17 @@ __KeccakF1600:
 	larl	$iotas,iotas
 	j	.Loop

+.LKeccakP1600_12_int:
+	st${g}	%r14,$SIZE_T*14($sp)
+	lg	@C[0],$A[4][0]($src)
+	lg	@C[1],$A[4][1]($src)
+	lg	@C[2],$A[4][2]($src)
+	lg	@C[3],$A[4][3]($src)
+	lg	@C[4],$A[4][4]($src)
+	larl	$iotas,iotas
+	la	$iotas,96($iotas)
+	j	.Loop
+
 .align	16
 .Loop:
 	lg	@D[0],$A[0][0]($src)
@@ -337,6 +352,7 @@ $code.=<<___;
 ___
 }
 {
+my $p12_start = length($code);
 $code.=<<___;
 .type	KeccakF1600,\@function
 .align	32
@@ -392,9 +408,15 @@ KeccakF1600:
 	br	%r14
 .size	KeccakF1600,.-KeccakF1600
 ___
+
+my $p12 = rename_labels(substr($code, $p12_start),
+                        "KeccakF1600", "KeccakP1600_12");
+$p12 =~ s/__KeccakF1600/.LKeccakP1600_12_int/g;
+$code .= $p12;
 }
 { my ($A_flat,$inp,$len,$bsz) = map("%r$_",(2..5));

+my $p12_start = length($code);
 $code.=<<___;
 .globl	SHA3_absorb
 .type	SHA3_absorb,\@function
@@ -472,9 +494,15 @@ SHA3_absorb:
 	br	%r14
 .size	SHA3_absorb,.-SHA3_absorb
 ___
+
+my $p12 = rename_labels(substr($code, $p12_start),
+                        "SHA3_absorb", "ossl_keccak1600_p12_absorb");
+$p12 =~ s/__KeccakF1600/.LKeccakP1600_12_int/g;
+$code .= $p12;
 }
 { my ($A_flat,$out,$len,$bsz,$next) = map("%r$_",(2..6));

+my $p12_start = length($code);
 $code.=<<___;
 .globl	SHA3_squeeze
 .type	SHA3_squeeze,\@function
@@ -524,6 +552,11 @@ SHA3_squeeze:
 	br	%r14
 .size	SHA3_squeeze,.-SHA3_squeeze
 ___
+
+my $p12 = rename_labels(substr($code, $p12_start),
+                        "SHA3_squeeze", "ossl_keccak1600_p12_squeeze");
+$p12 =~ s/\.LKeccakF1600/.LKeccakP1600_12/g;
+$code .= $p12;
 }
 $code.=<<___;
 .align	256
diff --git a/crypto/sha/asm/keccak1600-x86_64.pl b/crypto/sha/asm/keccak1600-x86_64.pl
index 3794949e8a..1908bf3d03 100755
--- a/crypto/sha/asm/keccak1600-x86_64.pl
+++ b/crypto/sha/asm/keccak1600-x86_64.pl
@@ -50,6 +50,10 @@
 #	improved by 14% by replacing rotates with double-precision
 #	shift with same register as source and destination.

+use FindBin qw($Bin);
+use lib "$Bin";
+require "keccak1600-common.pl";
+
 # $output is the last argument if it looks like a file (it has an extension)
 # $flavour is the first argument if it doesn't look like a file
 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
@@ -347,7 +351,10 @@ $code.=<<___;
 	ret
 .cfi_endproc
 .size	__KeccakF1600,.-__KeccakF1600
+___

+my $p12_start = length($code);
+$code.=<<___;
 .type	KeccakF1600,\@abi-omnipotent
 .align	32
 KeccakF1600:
@@ -409,14 +416,21 @@ KeccakF1600:
 .size	KeccakF1600,.-KeccakF1600
 ___

+my $p12 = rename_labels(substr($code, $p12_start),
+                        "KeccakF1600", "KeccakP1600_12");
+$p12 =~ s/lea\tiotas\(%rip\)/lea\t96+iotas(%rip)/;
+$code .= $p12;
+
 { my ($A_flat,$inp,$len,$bsz) = ("%rdi","%rsi","%rdx","%rcx");
      ($A_flat,$inp) = ("%r8","%r9");
+$p12_start = length($code);
 $code.=<<___;
 .globl	SHA3_absorb
 .type	SHA3_absorb,\@function,4
 .align	32
 SHA3_absorb:
 .cfi_startproc
+	endbranch
 	push	%rbx
 .cfi_push	%rbx
 	push	%rbp
@@ -502,16 +516,24 @@ SHA3_absorb:
 .cfi_endproc
 .size	SHA3_absorb,.-SHA3_absorb
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_absorb", "ossl_keccak1600_p12_absorb");
+$p12 =~ s/\n\tlea\tiotas\(%rip\),\Q$iotas\E\n/\n/;
+$p12 =~ s/\n\tcall\t__KeccakF1600/\n\tlea\t96+iotas(%rip),$iotas\n\n\tcall\t__KeccakF1600/;
+$code .= $p12;
 }
 { my ($A_flat,$out,$len,$bsz,$next) = ("%rdi","%rsi","%rdx","%rcx","%r8");
      ($out,$len,$bsz) = ("%r12","%r13","%r14");

+$p12_start = length($code);
 $code.=<<___;
 .globl	SHA3_squeeze
 .type	SHA3_squeeze,\@function,5
 .align	32
 SHA3_squeeze:
 .cfi_startproc
+	endbranch
 	push	%r12
 .cfi_push	%r12
 	push	%r13
@@ -565,6 +587,12 @@ SHA3_squeeze:
 .cfi_endproc
 .size	SHA3_squeeze,.-SHA3_squeeze
 ___
+
+$p12 = rename_labels(substr($code, $p12_start),
+                     "SHA3_squeeze", "ossl_keccak1600_p12_squeeze");
+$p12 =~ s/KeccakF1600/KeccakP1600_12/g;
+$p12 =~ s/(pop\t%r12\n)\.cfi_pop\t%r13/$1.cfi_pop\t%r12/;
+$code .= $p12;
 }
 $code.=<<___;
 .section .rodata align=256
diff --git a/crypto/sha/build.info b/crypto/sha/build.info
index 88e8b9cc5e..06e688ac98 100644
--- a/crypto/sha/build.info
+++ b/crypto/sha/build.info
@@ -118,6 +118,7 @@ GENERATE[sha256-x86_64.s]=asm/sha512-x86_64.pl
 GENERATE[sha256-mb-x86_64.s]=asm/sha256-mb-x86_64.pl
 GENERATE[sha512-x86_64.s]=asm/sha512-x86_64.pl
 GENERATE[keccak1600-x86_64.s]=asm/keccak1600-x86_64.pl
+DEPEND[keccak1600-x86_64.s]=asm/keccak1600-common.pl

 GENERATE[sha1-sparcv9a.S]=asm/sha1-sparcv9a.pl
 GENERATE[sha1-sparcv9.S]=asm/sha1-sparcv9.pl
@@ -133,6 +134,7 @@ GENERATE[sha512-ppc.s]=asm/sha512-ppc.pl
 GENERATE[sha256p8-ppc.s]=asm/sha512p8-ppc.pl
 GENERATE[sha512p8-ppc.s]=asm/sha512p8-ppc.pl
 GENERATE[keccak1600-ppc64.s]=asm/keccak1600-ppc64.pl
+DEPEND[keccak1600-ppc64.s]=asm/keccak1600-common.pl

 GENERATE[sha1-parisc.s]=asm/sha1-parisc.pl
 GENERATE[sha256-parisc.s]=asm/sha512-parisc.pl
@@ -161,6 +163,7 @@ INCLUDE[sha256-armv4.o]=..
 GENERATE[sha512-armv4.S]=asm/sha512-armv4.pl
 INCLUDE[sha512-armv4.o]=..
 GENERATE[keccak1600-armv4.S]=asm/keccak1600-armv4.pl
+DEPEND[keccak1600-armv4.S]=asm/keccak1600-common.pl
 INCLUDE[keccak1600-armv4.o]=..

 GENERATE[sha1-armv8.S]=asm/sha1-armv8.pl
@@ -170,6 +173,7 @@ INCLUDE[sha256-armv8.o]=..
 GENERATE[sha512-armv8.S]=asm/sha512-armv8.pl
 INCLUDE[sha512-armv8.o]=..
 GENERATE[keccak1600-armv8.S]=asm/keccak1600-armv8.pl
+DEPEND[keccak1600-armv8.S]=asm/keccak1600-common.pl
 INCLUDE[keccak1600-armv8.o]=..

 GENERATE[sha1-s390x.S]=asm/sha1-s390x.pl
@@ -179,6 +183,7 @@ INCLUDE[sha256-s390x.o]=..
 GENERATE[sha512-s390x.S]=asm/sha512-s390x.pl
 INCLUDE[sha512-s390x.o]=..
 GENERATE[keccak1600-s390x.S]=asm/keccak1600-s390x.pl
+DEPEND[keccak1600-s390x.S]=asm/keccak1600-common.pl

 GENERATE[sha1-c64xplus.S]=asm/sha1-c64xplus.pl
 GENERATE[sha256-c64xplus.S]=asm/sha256-c64xplus.pl
diff --git a/crypto/sha/keccak1600.c b/crypto/sha/keccak1600.c
index b4cbd6b563..a15451519f 100644
--- a/crypto/sha/keccak1600.c
+++ b/crypto/sha/keccak1600.c
@@ -16,6 +16,10 @@
 size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
     size_t r);
 void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r, int next);
+size_t ossl_keccak1600_p12_absorb(uint64_t A[5][5],
+    const unsigned char *inp, size_t len, size_t r);
+void ossl_keccak1600_p12_squeeze(uint64_t A[5][5], unsigned char *out,
+    size_t len, size_t r, int next);

 #if !defined(KECCAK1600_ASM) || !defined(SELFTEST)

@@ -244,6 +248,19 @@ static void KeccakF1600(uint64_t A[5][5])
     }
 }

+static void KeccakP1600_12(uint64_t A[5][5])
+{
+    size_t i;
+
+    for (i = 12; i < 24; i++) {
+        Theta(A);
+        Rho(A);
+        Pi(A);
+        Chi(A);
+        Iota(A, i);
+    }
+}
+
 #elif defined(KECCAK_1X)
 /*
  * This implementation is optimization of above code featuring unroll
@@ -375,6 +392,15 @@ static void KeccakF1600(uint64_t A[5][5])
     }
 }

+static void KeccakP1600_12(uint64_t A[5][5])
+{
+    size_t i;
+
+    for (i = 12; i < 24; i++) {
+        Round(A, i);
+    }
+}
+
 #elif defined(KECCAK_1X_ALT)
 /*
  * This is variant of above KECCAK_1X that reduces requirement for
@@ -518,6 +544,15 @@ static void KeccakF1600(uint64_t A[5][5])
     }
 }

+static void KeccakP1600_12(uint64_t A[5][5])
+{
+    size_t i;
+
+    for (i = 12; i < 24; i++) {
+        Round(A, i);
+    }
+}
+
 #elif defined(KECCAK_2X)
 /*
  * This implementation is variant of KECCAK_1X above with outer-most
@@ -676,6 +711,35 @@ static void KeccakF1600(uint64_t A[5][5])
 #endif
 }

+static void KeccakP1600_12(uint64_t A[5][5])
+{
+    uint64_t T[5][5];
+    size_t i;
+
+#ifdef KECCAK_COMPLEMENTING_TRANSFORM
+    A[0][1] = ~A[0][1];
+    A[0][2] = ~A[0][2];
+    A[1][3] = ~A[1][3];
+    A[2][2] = ~A[2][2];
+    A[3][2] = ~A[3][2];
+    A[4][0] = ~A[4][0];
+#endif
+
+    for (i = 12; i < 24; i += 2) {
+        Round(T, A, i);
+        Round(A, T, i + 1);
+    }
+
+#ifdef KECCAK_COMPLEMENTING_TRANSFORM
+    A[0][1] = ~A[0][1];
+    A[0][2] = ~A[0][2];
+    A[1][3] = ~A[1][3];
+    A[2][2] = ~A[2][2];
+    A[3][2] = ~A[3][2];
+    A[4][0] = ~A[4][0];
+#endif
+}
+
 #else /* define KECCAK_INPLACE to compile this code path */
 /*
  * This implementation is KECCAK_1X from above combined 4 times with
@@ -976,6 +1040,15 @@ static void KeccakF1600(uint64_t A[5][5])
     }
 }

+static void KeccakP1600_12(uint64_t A[5][5])
+{
+    size_t i;
+
+    for (i = 12; i < 24; i += 4) {
+        FourRounds(A, i);
+    }
+}
+
 #endif

 static uint64_t BitInterleave(uint64_t Ai)
@@ -1159,6 +1232,65 @@ void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r,
         }
     }
 }
+
+size_t ossl_keccak1600_p12_absorb(uint64_t A[5][5],
+    const unsigned char *inp, size_t len, size_t r)
+{
+    uint64_t *A_flat = (uint64_t *)A;
+    size_t i, w = r / 8;
+
+    assert(r < (25 * sizeof(A[0][0])) && (r % 8) == 0);
+
+    while (len >= r) {
+        for (i = 0; i < w; i++) {
+            uint64_t Ai = (uint64_t)inp[0] | (uint64_t)inp[1] << 8 | (uint64_t)inp[2] << 16 | (uint64_t)inp[3] << 24 | (uint64_t)inp[4] << 32 | (uint64_t)inp[5] << 40 | (uint64_t)inp[6] << 48 | (uint64_t)inp[7] << 56;
+            inp += 8;
+
+            A_flat[i] ^= BitInterleave(Ai);
+        }
+        KeccakP1600_12(A);
+        len -= r;
+    }
+
+    return len;
+}
+
+void ossl_keccak1600_p12_squeeze(uint64_t A[5][5], unsigned char *out,
+    size_t len, size_t r, int next)
+{
+    uint64_t *A_flat = (uint64_t *)A;
+    size_t i, w = r / 8;
+
+    assert(r < (25 * sizeof(A[0][0])) && (r % 8) == 0);
+
+    while (len != 0) {
+        if (next)
+            KeccakP1600_12(A);
+        next = 1;
+        for (i = 0; i < w && len != 0; i++) {
+            uint64_t Ai = BitDeinterleave(A_flat[i]);
+
+            if (len < 8) {
+                for (i = 0; i < len; i++) {
+                    *out++ = (unsigned char)Ai;
+                    Ai >>= 8;
+                }
+                return;
+            }
+
+            out[0] = (unsigned char)(Ai);
+            out[1] = (unsigned char)(Ai >> 8);
+            out[2] = (unsigned char)(Ai >> 16);
+            out[3] = (unsigned char)(Ai >> 24);
+            out[4] = (unsigned char)(Ai >> 32);
+            out[5] = (unsigned char)(Ai >> 40);
+            out[6] = (unsigned char)(Ai >> 48);
+            out[7] = (unsigned char)(Ai >> 56);
+            out += 8;
+            len -= 8;
+        }
+    }
+}
 #endif

 #ifdef SELFTEST
diff --git a/crypto/sha/sha3.c b/crypto/sha/sha3.c
index 5c8754cfd6..a12469d644 100644
--- a/crypto/sha/sha3.c
+++ b/crypto/sha/sha3.c
@@ -170,15 +170,16 @@ int ossl_sha3_final_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t outl

 /*
  * This method can be called multiple times.
- * Rather than heavily modifying assembler for SHA3_squeeze(),
- * we instead just use the limitations of the existing function.
- * i.e. Only request multiples of the ctx->block_size when calling
- * SHA3_squeeze(). For output length requests smaller than the
+ * Rather than requiring low-level squeeze functions to buffer partial
+ * blocks, use their existing block-oriented interface.
+ * i.e. Only request multiples of the ctx->block_size from the squeeze
+ * callback. For output length requests smaller than the
  * ctx->block_size just request a single ctx->block_size bytes and
  * buffer the results. The next request will use the buffer first
  * to grab output bytes.
  */
-int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t outlen)
+int ossl_keccak_block_squeeze(KECCAK1600_CTX *ctx, unsigned char *out,
+    size_t outlen, keccak_absorb_fn *absorb, keccak_squeeze_fn *squeeze)
 {
     size_t bsz = ctx->block_size;
     size_t num = ctx->bufsz;
@@ -199,7 +200,7 @@ int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t o
         memset(ctx->buf + num, 0, bsz - num);
         ctx->buf[num] = ctx->pad;
         ctx->buf[bsz - 1] |= 0x80;
-        (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
+        (void)absorb(ctx->A, ctx->buf, bsz, bsz);
         num = ctx->bufsz = 0;
         next = 0;
     }
@@ -224,14 +225,14 @@ int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t o
     /* Step 2. Copy full sized squeezed blocks to the output buffer directly */
     if (outlen >= bsz) {
         len = bsz * (outlen / bsz);
-        SHA3_squeeze(ctx->A, out, len, bsz, next);
+        squeeze(ctx->A, out, len, bsz, next);
         next = 1;
         out += len;
         outlen -= len;
     }
     if (outlen > 0) {
         /* Step 3. Squeeze one more block into a buffer */
-        SHA3_squeeze(ctx->A, ctx->buf, bsz, bsz, next);
+        squeeze(ctx->A, ctx->buf, bsz, bsz, next);
         memcpy(out, ctx->buf, outlen);
         /* Step 4. Remember the leftover part of the squeezed block */
         ctx->bufsz = bsz - outlen;
@@ -239,6 +240,13 @@ int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t o
     return 1;
 }

+int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out,
+    size_t outlen)
+{
+    return ossl_keccak_block_squeeze(ctx, out, outlen, SHA3_absorb,
+        SHA3_squeeze);
+}
+
 static PROV_SHA3_METHOD shake_generic_meth = {
     ossl_sha3_absorb_default,
     ossl_sha3_final_default,
diff --git a/doc/man3/EVP_DigestInit.pod b/doc/man3/EVP_DigestInit.pod
index 13c85e6c9b..bb25b9b473 100644
--- a/doc/man3/EVP_DigestInit.pod
+++ b/doc/man3/EVP_DigestInit.pod
@@ -532,15 +532,17 @@ following OSSL_PARAM keys:

 Sets or gets the digest length for extendable output functions.
 The value should not exceed what can be given using a B<size_t>.
-It may be used by SHAKE-128, CSHAKE-128, SHAKE-256 and CSHAKE-256, to set the
-output length used by EVP_DigestFinal_ex() and EVP_DigestFinal().
+It may be used by the SHAKE, CSHAKE, TurboSHAKE and KangarooTwelve XOF
+algorithms to set the output length used by EVP_DigestFinal_ex() and
+EVP_DigestFinal().

 =item "size" (B<OSSL_DIGEST_PARAM_SIZE>) <unsigned integer>

 Sets or gets a fixed digest length.
 The value should not exceed what can be given using a B<size_t>.
 It may be used by BLAKE2B-512 to set the output length used by
-EVP_DigestFinal_ex() and EVP_DigestFinal().
+EVP_DigestFinal_ex() and EVP_DigestFinal().  It may be used by the SHAKE,
+CSHAKE, TurboSHAKE and KangarooTwelve XOF algorithms as an alias of "xoflen".

 =back

@@ -558,10 +560,17 @@ It is used by the MDC2 algorithm.
 Sets the function name string.
 It is used by L<EVP_MD-CSHAKE(7)>.

-=item "customization" (B<OSSL_DIGEST_PARAM_CUSTOMIZATION>)<UTF8 string>
+=item "customization" (B<OSSL_DIGEST_PARAM_CUSTOMIZATION>)<UTF8 string or octet string>

 Sets a customisation string.
-It is used by L<EVP_MD-CSHAKE(7)>.
+It is used by L<EVP_MD-CSHAKE(7)> as a UTF8 string with a length of at most
+512 bytes, and by L<EVP_MD-KANGAROOTWELVE(7)> as an octet string with a length
+of at most 512 bytes.
+
+=item "domain-separator" (B<OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR>) <unsigned integer>
+
+Sets the TurboSHAKE domain separator.
+It is used by L<EVP_MD-TURBOSHAKE(7)>.

 =item "properties" (B<OSSL_DIGEST_PARAM_PROPERTIES>)<UTF8 string>

diff --git a/doc/man7/EVP_MD-SHAKE.pod b/doc/man7/EVP_MD-SHAKE.pod
index cc8d8a47cb..615742e13f 100644
--- a/doc/man7/EVP_MD-SHAKE.pod
+++ b/doc/man7/EVP_MD-SHAKE.pod
@@ -3,12 +3,13 @@
 =head1 NAME

 EVP_MD-SHAKE, EVP_MD-CSHAKE, EVP_MD-CSHAKE-KECCAK,
+EVP_MD-TURBOSHAKE, EVP_MD-KANGAROOTWELVE
 - The SHAKE / KECCAK family EVP_MD implementations

 =head1 DESCRIPTION

-Support for computing SHAKE, CSHAKE or CSHAKE-KECCAK digests through the
-B<EVP_MD> API.
+Support for computing SHAKE, CSHAKE, CSHAKE-KECCAK, TurboSHAKE, or
+KangarooTwelve (KT) digests through the B<EVP_MD> API.

 CSHAKE is an Extendable Output Function (XOF), that allows custom strings
 "n" and "s". If these strings are both empty then it is identical to SHAKE,
@@ -17,10 +18,19 @@ otherwise it uses CSHAKE-KECCAK.
 CSHAKE-KECCAK is an Extendable Output Function (XOF), with a definition
 similar to SHAKE but appends 2 extra zero bits. It is used internally by CSHAKE.

+TurboSHAKE is an Extendable Output Function (XOF) defined by RFC 9861. It
+uses the same rate and capacity as SHAKE, but uses Keccak-p[1600,12] and a
+domain separation byte.
+
+KT-128 and KT-256 are KangarooTwelve Extendable Output Functions (XOFs)
+defined by RFC 9861. They use tree hashing over TurboSHAKE and support a
+customisation string.
+
 =head2 Identities

-This implementation is available in the FIPS provider as well as the default
-provider, and includes the following varieties:
+The SHAKE, CSHAKE, and CSHAKE-KECCAK implementations are available in the FIPS
+provider as well as the default provider. TurboSHAKE and KangarooTwelve are
+available in the default provider. The following varieties are included:

 =over 4

@@ -54,6 +64,22 @@ by L<EVP_MAC-KMAC256(7)>.  Using the notation from NIST FIPS 202
 (Section 6.2), we have S<KECCAK-KMAC-256(M, d)> = S<KECCAK[512](M || 00, d)>
 (see the description of KMAC256 in Appendix A of NIST SP 800-185).

+=item TURBOSHAKE-128
+
+Known names are "TURBOSHAKE-128" and "TURBOSHAKE128".
+
+=item TURBOSHAKE-256
+
+Known names are "TURBOSHAKE-256" and "TURBOSHAKE256".
+
+=item KT-128
+
+Known names are "KT-128" and "KT128".
+
+=item KT-256
+
+Known names are "KT-256" and "KT256".
+
 =back

 =head2 Parameters
@@ -74,11 +100,15 @@ The CSHAKE-128 and CSHAKE-256 implementations have default digest lengths of
 32 and 64 bytes respectively (which correspond to security strengths of 128 and
 256 bits respectively).

+The TURBOSHAKE-128 and KT-128 implementations have a default digest length of
+32 bytes. The TURBOSHAKE-256 and KT-256 implementations have a default digest
+length of 64 bytes.
+
 For SHAKE this parameter must be set before calling either EVP_DigestFinal_ex()
 or EVP_DigestFinal(), since these functions were not designed to handle
-variable length output. If it is not set CSHAKE will use the default value.
-It is recommended to either use EVP_DigestSqueeze() or
-EVP_DigestFinalXOF() instead.
+variable length output. If it is not set, CSHAKE, TurboSHAKE, and
+KangarooTwelve will use the default value. It is recommended to either use
+EVP_DigestSqueeze() or EVP_DigestFinalXOF() instead.

 =item "size" (B<OSSL_DIGEST_PARAM_SIZE>) <unsigned integer>

@@ -89,11 +119,18 @@ An alias of "xoflen".
 Sets the function name string used by CSHAKE that can be set to one of
 "", "TupleHash", "ParallelHash" or "KMAC". The default value is "".

-=item "customization" (B<OSSL_DIGEST_PARAM_CUSTOMIZATION>)<UTF8 string>
+=item "customization" (B<OSSL_DIGEST_PARAM_CUSTOMIZATION>)<UTF8 string or octet string>
+
+Sets a customisation string used by CSHAKE or KangarooTwelve.
+For CSHAKE, it may be set as a UTF8 string with a length of at most 512
+bytes. For KangarooTwelve, it may be set as an octet string with a length of
+at most 512 bytes. It is empty by default.

-Sets a customisation string used by CSHAKE.
-It is an optional value with a length of at most 512 bytes, and is
-empty by default.
+=item "domain-separator" (B<OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR>) <unsigned integer>
+
+Sets or gets the TurboSHAKE domain separation byte. Valid values are 1 to 127,
+inclusive. The default value is 31 (0x1f). This parameter is only supported by
+TURBOSHAKE-128 and TURBOSHAKE-256.

 =item "properties" (B<OSSL_DIGEST_PARAM_PROPERTIES>) <UTF8 string>

@@ -106,11 +143,17 @@ See L<EVP_DigestInit(3)/PARAMETERS> for further information related to parameter

 =head1 NOTES

-For SHAKE-128 and CSHAKE-128, to ensure the maximum security strength of
-128 bits, the output length passed to EVP_DigestFinalXOF() should be at least 32.
+For SHAKE-128, CSHAKE-128, TURBOSHAKE-128, and KT-128, to ensure the maximum
+security strength of 128 bits, the output length passed to EVP_DigestFinalXOF()
+should be at least 32.
+
+For SHAKE-256, CSHAKE-256, TURBOSHAKE-256, and KT-256, to ensure the maximum
+security strength of 256 bits, the output length passed to EVP_DigestFinalXOF()
+should be at least 64.

-For SHAKE-256 and CSHAKE-256, to ensure the maximum security strength of
-256 bits, the output length passed to EVP_DigestFinalXOF() should be at least 64.
+KangarooTwelve uses TurboSHAKE domain separation bytes 0x06, 0x07, and 0x0b
+internally. Protocols that use both KangarooTwelve and TurboSHAKE should avoid
+these TurboSHAKE domain separator values.

 The SHA3 specification allows bit strings to be used, but OpenSSL only allows
 byte strings for inputs, and outputs.
@@ -125,6 +168,8 @@ byte strings for inputs, and outputs.

 =item SP800-185 Section 4 KMAC

+=item RFC 9861 TurboSHAKE and KangarooTwelve
+
 =back

 =head1 SEE ALSO
@@ -138,6 +183,8 @@ digest length.

 CSHAKE-128 and CSHAKE-256 were added in OpenSSL 4.0

+TURBOSHAKE-128, TURBOSHAKE-256, KT-128, and KT-256 were added in OpenSSL 4.2.
+
 =head1 COPYRIGHT

 Copyright 2020-2026 The OpenSSL Project Authors. All Rights Reserved.
diff --git a/doc/man7/OSSL_PROVIDER-default.pod b/doc/man7/OSSL_PROVIDER-default.pod
index 96b76a8cd0..d83d7e6057 100644
--- a/doc/man7/OSSL_PROVIDER-default.pod
+++ b/doc/man7/OSSL_PROVIDER-default.pod
@@ -65,6 +65,10 @@ The OpenSSL default provider supports these operations and algorithms:

 =item CSHAKE-KECCAK, see L<EVP_MD-CSHAKE-KECCAK(7)>

+=item TurboSHAKE, see L<EVP_MD-TURBOSHAKE(7)>
+
+=item KangarooTwelve (KT), see L<EVP_MD-KANGAROOTWELVE(7)>
+
 =item BLAKE2, see L<EVP_MD-BLAKE2(7)>

 =item SM3, see L<EVP_MD-SM3(7)>
@@ -595,6 +599,9 @@ Support for CSHAKE-128 and CSHAKE-256 was added in OpenSSL 4.0.
 Support for B<MLKEM512X25519> and B<SecP256r1MLKEM512> was added in OpenSSL
 4.2.

+Support for TURBOSHAKE-128, TURBOSHAKE-256, KT-128, and KT-256 was added in
+OpenSSL 4.2.
+
 =head1 COPYRIGHT

 Copyright 2020-2026 The OpenSSL Project Authors. All Rights Reserved.
diff --git a/include/internal/sha3.h b/include/internal/sha3.h
index 0e0ab76fb5..1b9b9b6bb1 100644
--- a/include/internal/sha3.h
+++ b/include/internal/sha3.h
@@ -25,6 +25,10 @@ typedef struct keccak_st KECCAK1600_CTX;
 typedef size_t(sha3_absorb_fn)(KECCAK1600_CTX *vctx, const unsigned char *in, size_t inlen);
 typedef int(sha3_final_fn)(KECCAK1600_CTX *vctx, unsigned char *out, size_t outlen);
 typedef int(sha3_squeeze_fn)(KECCAK1600_CTX *vctx, unsigned char *out, size_t outlen);
+typedef size_t(keccak_absorb_fn)(uint64_t A[5][5],
+    const unsigned char *in, size_t inlen, size_t rate);
+typedef void(keccak_squeeze_fn)(uint64_t A[5][5], unsigned char *out,
+    size_t outlen, size_t rate, int next);

 typedef struct prov_sha3_meth_st {
     sha3_absorb_fn *absorb;
@@ -61,9 +65,52 @@ int ossl_sha3_squeeze(KECCAK1600_CTX *ctx, unsigned char *out, size_t outlen);
 size_t ossl_sha3_absorb_default(KECCAK1600_CTX *ctx, const unsigned char *inp, size_t len);
 int ossl_sha3_final_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t outlen);
 int ossl_shake_squeeze_default(KECCAK1600_CTX *ctx, unsigned char *out, size_t outlen);
+/**
+ * @brief Squeeze bytes using block-oriented Keccak callbacks.
+ *
+ * Pads and absorbs buffered input on the first squeeze, then buffers unused
+ * output bytes for later calls. The caller updates ctx->xof_state after success.
+ *
+ * @param ctx sponge context with the block size and padding set
+ * @param out output buffer for outlen bytes
+ * @param outlen number of bytes to produce
+ * @param absorb callback that absorbs complete rate blocks
+ * @param squeeze callback that squeezes blocks using the same permutation
+ * @returns 1
+ */
+int ossl_keccak_block_squeeze(KECCAK1600_CTX *ctx, unsigned char *out,
+    size_t outlen, keccak_absorb_fn *absorb, keccak_squeeze_fn *squeeze);

 size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
     size_t r);
+/**
+ * @brief Absorb complete blocks using Keccak-p[1600,12].
+ *
+ * Does not pad or buffer the remaining input bytes.
+ *
+ * @param A sponge state, updated in place
+ * @param inp input buffer containing len bytes
+ * @param len number of available input bytes
+ * @param r rate in bytes, a positive multiple of 8 less than 200
+ * @returns number of unabsorbed input bytes, less than r
+ */
+size_t ossl_keccak1600_p12_absorb(uint64_t A[5][5],
+    const unsigned char *inp, size_t len, size_t r);
+/**
+ * @brief Squeeze bytes using Keccak-p[1600,12].
+ *
+ * The state must already include the padded input. No offset within the final
+ * output block is retained, so calls preceding another squeeze must produce
+ * whole rate blocks. The assembler implementations require len > 0.
+ *
+ * @param A sponge state, updated in place
+ * @param out output buffer for len bytes
+ * @param len positive number of bytes to produce
+ * @param r rate in bytes, a positive multiple of 8 less than 200
+ * @param next 0 to output the current state first, or 1 to permute it first
+ */
+void ossl_keccak1600_p12_squeeze(uint64_t A[5][5], unsigned char *out,
+    size_t len, size_t r, int next);

 /* Multi-buffer (x4) Keccak-f[1600] context and API */
 #if defined(KECCAK1600_ASM)                                                               \
diff --git a/include/openssl/core_names.h.in b/include/openssl/core_names.h.in
index 7d8080f59e..b0c2a17321 100644
--- a/include/openssl/core_names.h.in
+++ b/include/openssl/core_names.h.in
@@ -53,6 +53,10 @@ extern "C" {
 #define OSSL_DIGEST_NAME_SHA3_512 "SHA3-512"
 #define OSSL_DIGEST_NAME_KECCAK_KMAC128 "KECCAK-KMAC-128"
 #define OSSL_DIGEST_NAME_KECCAK_KMAC256 "KECCAK-KMAC-256"
+#define OSSL_DIGEST_NAME_TURBOSHAKE128 "TURBOSHAKE-128"
+#define OSSL_DIGEST_NAME_TURBOSHAKE256 "TURBOSHAKE-256"
+#define OSSL_DIGEST_NAME_KT128 "KT-128"
+#define OSSL_DIGEST_NAME_KT256 "KT-256"
 #define OSSL_DIGEST_NAME_SM3 "SM3"

 /* Known MAC names */
diff --git a/providers/defltprov.c b/providers/defltprov.c
index c902ad97b1..70546f14d4 100644
--- a/providers/defltprov.c
+++ b/providers/defltprov.c
@@ -132,6 +132,17 @@ static const OSSL_ALGORITHM deflt_digests[] = {
     { PROV_NAMES_CSHAKE_128, "provider=default", ossl_cshake_128_functions },
     { PROV_NAMES_CSHAKE_256, "provider=default", ossl_cshake_256_functions },

+#ifndef OPENSSL_NO_TURBOSHAKE
+    { PROV_NAMES_TURBOSHAKE_128, "provider=default",
+        ossl_turboshake_128_functions },
+    { PROV_NAMES_TURBOSHAKE_256, "provider=default",
+        ossl_turboshake_256_functions },
+#endif /* OPENSSL_NO_TURBOSHAKE */
+#ifndef OPENSSL_NO_KT
+    { PROV_NAMES_KT_128, "provider=default", ossl_kt_128_functions },
+    { PROV_NAMES_KT_256, "provider=default", ossl_kt_256_functions },
+#endif /* OPENSSL_NO_KT */
+
 #ifndef OPENSSL_NO_BLAKE2
     /*
      * https://blake2.net/ doesn't specify size variants,
diff --git a/providers/implementations/digests/build.info b/providers/implementations/digests/build.info
index b2b776c57f..9c4311e1a4 100644
--- a/providers/implementations/digests/build.info
+++ b/providers/implementations/digests/build.info
@@ -10,6 +10,8 @@ ENDIF
 $SHA1_GOAL=../../libdefault.a ../../libfips.a
 $SHA2_GOAL=../../libdefault.a ../../libfips.a
 $SHA3_GOAL=../../libdefault.a ../../libfips.a
+$TURBOSHAKE_GOAL=../../libdefault.a
+$KT_GOAL=../../libdefault.a
 $BLAKE2_GOAL=../../libdefault.a
 $SM3_GOAL=../../libdefault.a
 $MD5_GOAL=../../libdefault.a
@@ -33,6 +35,14 @@ SOURCE[$DIGEST_COMMON_GOAL]=digestcommon.c
 SOURCE[$SHA2_GOAL]=sha2_prov.c
 SOURCE[$SHA3_GOAL]=sha3_prov.c cshake_prov.c

+IF[{- !$disabled{turboshake} -}]
+  SOURCE[$TURBOSHAKE_GOAL]=turboshake_prov.c
+ENDIF
+
+IF[{- !$disabled{kt} -}]
+  SOURCE[$KT_GOAL]=kt_prov.c
+ENDIF
+
 SOURCE[$NULL_GOAL]=null_prov.c

 IF[{- !$disabled{blake2} -}]
diff --git a/providers/implementations/digests/kt_prov.c b/providers/implementations/digests/kt_prov.c
new file mode 100644
index 0000000000..b8566a9318
--- /dev/null
+++ b/providers/implementations/digests/kt_prov.c
@@ -0,0 +1,396 @@
+/*
+ * Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <string.h>
+#include <openssl/core_dispatch.h>
+#include <openssl/core_names.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#include <openssl/params.h>
+#include <openssl/proverr.h>
+#include "internal/common.h"
+#include "internal/numbers.h" /* includes SIZE_MAX */
+#include "internal/sha3.h"
+#include "prov/digestcommon.h"
+#include "prov/implementations.h"
+#include "turboshake_prov.h"
+
+#define KT_FLAGS (PROV_DIGEST_FLAG_XOF | PROV_DIGEST_FLAG_ALGID_ABSENT)
+
+#define KT_CHUNK_SIZE 8192
+#define KT_MAX_CUSTOM_STRING 512
+#define KT_DOMAIN_FINAL_NODE 0x06
+#define KT_DOMAIN_SINGLE_NODE 0x07
+#define KT_DOMAIN_INTERMEDIATE_NODE 0x0b
+
+#include "providers/implementations/digests/kt_prov.inc"
+
+typedef struct kt_ctx_st {
+    size_t bitlen;
+    size_t xoflen;
+    size_t cvlen;
+    unsigned char *custom;
+    size_t custom_len;
+    KECCAK1600_CTX root;
+    KECCAK1600_CTX leaf;
+    size_t chunk_len;
+    size_t cv_count;
+    int tree_started;
+    int finalized;
+} KT_CTX;
+
+static OSSL_FUNC_digest_init_fn kt_init;
+static OSSL_FUNC_digest_update_fn kt_update;
+static OSSL_FUNC_digest_final_fn kt_final;
+static OSSL_FUNC_digest_squeeze_fn kt_squeeze;
+static OSSL_FUNC_digest_freectx_fn kt_freectx;
+static OSSL_FUNC_digest_dupctx_fn kt_dupctx;
+static OSSL_FUNC_digest_get_ctx_params_fn kt_get_ctx_params;
+static OSSL_FUNC_digest_gettable_ctx_params_fn kt_gettable_ctx_params;
+static OSSL_FUNC_digest_set_ctx_params_fn kt_set_ctx_params;
+static OSSL_FUNC_digest_settable_ctx_params_fn kt_settable_ctx_params;
+
+/*
+ * RFC 9861 length_encode() is not SP800-185 right_encode(): in particular,
+ * length_encode(0) is 00, not 00 01.
+ */
+static size_t kt_length_encode(size_t x, unsigned char *out)
+{
+    size_t n = 0, t = x, i;
+
+    while (t > 0) {
+        n++;
+        t >>= 8;
+    }
+    for (i = 0; i < n; i++)
+        out[n - i - 1] = (unsigned char)(x >> (8 * i));
+    out[n] = (unsigned char)n;
+    return n + 1;
+}
+
+static int kt_start_tree(KT_CTX *ctx)
+{
+    static const unsigned char kt_tree_marker[8] = {
+        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+
+    if (ctx->tree_started)
+        return 1;
+    ctx->root.pad = KT_DOMAIN_FINAL_NODE;
+    if (!ossl_sha3_absorb(&ctx->root, kt_tree_marker,
+            sizeof(kt_tree_marker))
+        || !ossl_turboshake_init_keccak(&ctx->leaf, ctx->bitlen,
+            KT_DOMAIN_INTERMEDIATE_NODE, ctx->cvlen))
+        return 0;
+    ctx->tree_started = 1;
+    ctx->chunk_len = 0;
+    return 1;
+}
+
+static int kt_finish_leaf(KT_CTX *ctx)
+{
+    unsigned char cv[64];
+    int ret = 0;
+
+    if (ctx->cv_count == SIZE_MAX) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_LENGTH_TOO_LARGE);
+        return 0;
+    }
+    if (!ossl_sha3_final(&ctx->leaf, cv, ctx->cvlen)
+        || !ossl_sha3_absorb(&ctx->root, cv, ctx->cvlen))
+        goto err;
+    ctx->cv_count++;
+    ctx->chunk_len = 0;
+    ret = ossl_turboshake_init_keccak(&ctx->leaf, ctx->bitlen,
+        KT_DOMAIN_INTERMEDIATE_NODE, ctx->cvlen);
+err:
+    OPENSSL_cleanse(cv, sizeof(cv));
+    return ret;
+}
+
+static int kt_absorb_s(KT_CTX *ctx, const unsigned char *in, size_t inlen)
+{
+    size_t len;
+
+    if (inlen == 0)
+        return 1;
+    if (ctx->finalized)
+        return 0;
+
+    while (inlen > 0) {
+        /* The next byte is byte 8193 of S, so switch to tree mode. */
+        if (!ctx->tree_started && ctx->chunk_len == KT_CHUNK_SIZE
+            && !kt_start_tree(ctx))
+            return 0;
+
+        len = KT_CHUNK_SIZE - ctx->chunk_len;
+        if (len > inlen)
+            len = inlen;
+        if (!ossl_sha3_absorb(ctx->tree_started ? &ctx->leaf : &ctx->root,
+                in, len))
+            return 0;
+        ctx->chunk_len += len;
+        in += len;
+        inlen -= len;
+        if (ctx->tree_started && ctx->chunk_len == KT_CHUNK_SIZE
+            && !kt_finish_leaf(ctx))
+            return 0;
+    }
+    return 1;
+}
+
+static int kt_final_absorb(KT_CTX *ctx)
+{
+    unsigned char enc[sizeof(size_t) + 1];
+    size_t enclen;
+    static const unsigned char kt_final_suffix[2] = { 0xff, 0xff };
+
+    if (ctx->finalized)
+        return 1;
+
+    enclen = kt_length_encode(ctx->custom_len, enc);
+    if (!kt_absorb_s(ctx, ctx->custom, ctx->custom_len)
+        || !kt_absorb_s(ctx, enc, enclen))
+        return 0;
+
+    if (ctx->tree_started) {
+        if (ctx->chunk_len > 0 && !kt_finish_leaf(ctx))
+            return 0;
+        enclen = kt_length_encode(ctx->cv_count, enc);
+        if (!ossl_sha3_absorb(&ctx->root, enc, enclen)
+            || !ossl_sha3_absorb(&ctx->root, kt_final_suffix,
+                sizeof(kt_final_suffix)))
+            return 0;
+    }
+    ctx->finalized = 1;
+    return 1;
+}
+
+static void *kt_newctx(ossl_unused void *provctx, size_t bitlen)
+{
+    KT_CTX *ctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return NULL;
+    ctx = OPENSSL_zalloc(sizeof(*ctx));
+    if (ctx == NULL)
+        return NULL;
+    ctx->bitlen = bitlen;
+    ctx->cvlen = bitlen == 128 ? 32 : 64;
+    ctx->xoflen = ctx->cvlen;
+    return ctx;
+}
+
+static int kt_init(void *vctx, const OSSL_PARAM params[])
+{
+    KT_CTX *ctx = vctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    OPENSSL_clear_free(ctx->custom, ctx->custom_len);
+    ctx->custom = NULL;
+    ctx->custom_len = 0;
+    ctx->xoflen = ctx->cvlen;
+    ctx->chunk_len = 0;
+    ctx->cv_count = 0;
+    ctx->tree_started = 0;
+    ctx->finalized = 0;
+    memset(&ctx->leaf, 0, sizeof(ctx->leaf));
+    if (!ossl_turboshake_init_keccak(&ctx->root, ctx->bitlen,
+            KT_DOMAIN_SINGLE_NODE, ctx->xoflen))
+        return 0;
+    return kt_set_ctx_params(vctx, params);
+}
+
+static int kt_update(void *vctx, const unsigned char *in, size_t inlen)
+{
+    KT_CTX *ctx = vctx;
+
+    return kt_absorb_s(ctx, in, inlen);
+}
+
+static int kt_final(void *vctx, unsigned char *out, size_t *outl,
+    size_t outsz)
+{
+    KT_CTX *ctx = vctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    if (outsz < ctx->xoflen)
+        return 0;
+    if (ctx->xoflen > 0
+        && (!kt_final_absorb(ctx)
+            || !ossl_sha3_final(&ctx->root, out, ctx->xoflen)))
+        return 0;
+    if (outl != NULL)
+        *outl = ctx->xoflen;
+    return 1;
+}
+
+static int kt_squeeze(void *vctx, unsigned char *out, size_t *outl,
+    size_t outsz)
+{
+    KT_CTX *ctx = vctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    if (outsz > 0
+        && (!kt_final_absorb(ctx)
+            || !ossl_sha3_squeeze(&ctx->root, out, outsz)))
+        return 0;
+    if (outl != NULL)
+        *outl = outsz;
+    return 1;
+}
+
+static void kt_freectx(void *vctx)
+{
+    KT_CTX *ctx = vctx;
+
+    if (ctx != NULL)
+        OPENSSL_clear_free(ctx->custom, ctx->custom_len);
+    OPENSSL_clear_free(ctx, sizeof(*ctx));
+}
+
+static void *kt_dupctx(void *vctx)
+{
+    KT_CTX *in = vctx;
+    KT_CTX *ret = ossl_prov_is_running() ? OPENSSL_malloc(sizeof(*ret)) : NULL;
+
+    if (ret == NULL)
+        return NULL;
+    *ret = *in;
+    ret->custom = NULL;
+    if (in->custom_len > 0) {
+        ret->custom = OPENSSL_memdup(in->custom, in->custom_len);
+        if (ret->custom == NULL) {
+            OPENSSL_clear_free(ret, sizeof(*ret));
+            return NULL;
+        }
+    }
+    return ret;
+}
+
+static const OSSL_PARAM *kt_gettable_ctx_params(ossl_unused void *ctx,
+    ossl_unused void *provctx)
+{
+    return kt_get_ctx_params_list;
+}
+
+static int kt_get_ctx_params(void *vctx, OSSL_PARAM params[])
+{
+    KT_CTX *ctx = vctx;
+    struct kt_get_ctx_params_st p;
+
+    if (ctx == NULL || !kt_get_ctx_params_decoder(params, &p))
+        return 0;
+
+    if (p.size != NULL && !OSSL_PARAM_set_size_t(p.size, ctx->xoflen)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    if (p.xoflen != NULL && !OSSL_PARAM_set_size_t(p.xoflen, ctx->xoflen)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    return 1;
+}
+
+static const OSSL_PARAM *kt_settable_ctx_params(ossl_unused void *ctx,
+    ossl_unused void *provctx)
+{
+    return kt_set_ctx_params_list;
+}
+
+static int kt_set_custom(KT_CTX *ctx, const OSSL_PARAM *p)
+{
+    const unsigned char *data = p->data;
+    unsigned char *custom = NULL;
+    size_t custom_len;
+
+    if (p->data_type != OSSL_PARAM_OCTET_STRING)
+        return 0;
+    custom_len = p->data_size;
+
+    /* Match the existing CSHAKE provider limit for customization strings. */
+    if (custom_len > KT_MAX_CUSTOM_STRING) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_CUSTOM_LENGTH);
+        return 0;
+    }
+
+    if (custom_len > 0) {
+        if (data == NULL)
+            return 0;
+        custom = OPENSSL_memdup(data, custom_len);
+        if (custom == NULL)
+            return 0;
+    }
+    OPENSSL_clear_free(ctx->custom, ctx->custom_len);
+    ctx->custom = custom;
+    ctx->custom_len = custom_len;
+    return 1;
+}
+
+static int kt_set_ctx_params(void *vctx, const OSSL_PARAM params[])
+{
+    KT_CTX *ctx = vctx;
+    struct kt_set_ctx_params_st p;
+    size_t xoflen;
+    int has_change = 0;
+
+    if (ctx == NULL || !kt_set_ctx_params_decoder(params, &p))
+        return 0;
+
+    has_change = p.xoflen != NULL || p.custom != NULL;
+    if (has_change && ctx->finalized)
+        return 0;
+
+    xoflen = ctx->xoflen;
+    if (p.xoflen != NULL
+        && !OSSL_PARAM_get_size_t(p.xoflen, &xoflen)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+
+    if (p.custom != NULL && !kt_set_custom(ctx, p.custom))
+        return 0;
+    ctx->xoflen = xoflen;
+    ctx->root.md_size = xoflen;
+    return 1;
+}
+
+#define IMPLEMENT_KT(bitlen)                                                    \
+    static OSSL_FUNC_digest_newctx_fn kt_##bitlen##_newctx;                     \
+    static void *kt_##bitlen##_newctx(void *provctx)                            \
+    {                                                                           \
+        return kt_newctx(provctx, bitlen);                                      \
+    }                                                                           \
+    PROV_FUNC_DIGEST_GET_PARAM(kt_##bitlen, SHA3_BLOCKSIZE(bitlen),             \
+        bitlen == 128 ? 32 : 64, KT_FLAGS)                                      \
+    const OSSL_DISPATCH ossl_kt_##bitlen##_functions[] = {                      \
+        { OSSL_FUNC_DIGEST_NEWCTX, (void (*)(void))kt_##bitlen##_newctx },      \
+        { OSSL_FUNC_DIGEST_INIT, (void (*)(void))kt_init },                     \
+        { OSSL_FUNC_DIGEST_UPDATE, (void (*)(void))kt_update },                 \
+        { OSSL_FUNC_DIGEST_FINAL, (void (*)(void))kt_final },                   \
+        { OSSL_FUNC_DIGEST_SQUEEZE, (void (*)(void))kt_squeeze },               \
+        { OSSL_FUNC_DIGEST_FREECTX, (void (*)(void))kt_freectx },               \
+        { OSSL_FUNC_DIGEST_DUPCTX, (void (*)(void))kt_dupctx },                 \
+        { OSSL_FUNC_DIGEST_SET_CTX_PARAMS, (void (*)(void))kt_set_ctx_params }, \
+        { OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS,                                 \
+            (void (*)(void))kt_settable_ctx_params },                           \
+        { OSSL_FUNC_DIGEST_GET_CTX_PARAMS, (void (*)(void))kt_get_ctx_params }, \
+        { OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS,                                 \
+            (void (*)(void))kt_gettable_ctx_params },                           \
+        PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(kt_##bitlen),                      \
+        PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END
+
+/* ossl_kt_128_functions */
+IMPLEMENT_KT(128)
+/* ossl_kt_256_functions */
+IMPLEMENT_KT(256)
diff --git a/providers/implementations/digests/kt_prov.inc.in b/providers/implementations/digests/kt_prov.inc.in
new file mode 100644
index 0000000000..c5fb00fe62
--- /dev/null
+++ b/providers/implementations/digests/kt_prov.inc.in
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+{-
+use OpenSSL::paramnames qw(produce_param_decoder);
+-}
+
+{- produce_param_decoder('kt_get_ctx_params',
+                         (['OSSL_DIGEST_PARAM_XOFLEN',   'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_SIZE',     'size',     'size_t'],
+                         )); -}
+
+{- produce_param_decoder('kt_set_ctx_params',
+                         (['OSSL_DIGEST_PARAM_XOFLEN',   'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_SIZE',     'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_CUSTOMIZATION', 'custom', 'octet_string'],
+                         )); -}
diff --git a/providers/implementations/digests/turboshake_prov.c b/providers/implementations/digests/turboshake_prov.c
new file mode 100644
index 0000000000..5c4c4d25a5
--- /dev/null
+++ b/providers/implementations/digests/turboshake_prov.c
@@ -0,0 +1,290 @@
+/*
+ * Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <string.h>
+#include <openssl/core_dispatch.h>
+#include <openssl/core_names.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#include <openssl/params.h>
+#include <openssl/proverr.h>
+#include "internal/common.h"
+#include "internal/sha3.h"
+#include "prov/digestcommon.h"
+#include "prov/implementations.h"
+#include "turboshake_prov.h"
+
+#define TURBOSHAKE_FLAGS (PROV_DIGEST_FLAG_XOF | PROV_DIGEST_FLAG_ALGID_ABSENT)
+
+#define TURBOSHAKE_DOMAIN_DEFAULT 0x1f
+#define TURBOSHAKE_DOMAIN_MIN 0x01
+#define TURBOSHAKE_DOMAIN_MAX 0x7f
+
+#include "providers/implementations/digests/turboshake_prov.inc"
+
+typedef struct turboshake_ctx_st {
+    KECCAK1600_CTX kctx;
+    size_t bitlen;
+} TURBOSHAKE_CTX;
+
+static OSSL_FUNC_digest_init_fn turboshake_init;
+static OSSL_FUNC_digest_update_fn turboshake_update;
+static OSSL_FUNC_digest_final_fn turboshake_final;
+static OSSL_FUNC_digest_squeeze_fn turboshake_squeeze;
+static OSSL_FUNC_digest_freectx_fn turboshake_freectx;
+static OSSL_FUNC_digest_dupctx_fn turboshake_dupctx;
+static OSSL_FUNC_digest_copyctx_fn turboshake_copyctx;
+static OSSL_FUNC_digest_get_ctx_params_fn turboshake_get_ctx_params;
+static OSSL_FUNC_digest_gettable_ctx_params_fn turboshake_gettable_ctx_params;
+static OSSL_FUNC_digest_set_ctx_params_fn turboshake_set_ctx_params;
+static OSSL_FUNC_digest_settable_ctx_params_fn turboshake_settable_ctx_params;
+
+static size_t turboshake_absorb_p12(KECCAK1600_CTX *ctx,
+    const unsigned char *inp, size_t len)
+{
+    return ossl_keccak1600_p12_absorb(ctx->A, inp, len, ctx->block_size);
+}
+
+static int turboshake_final_p12(KECCAK1600_CTX *ctx, unsigned char *out,
+    size_t outlen)
+{
+    size_t bsz = ctx->block_size;
+    size_t num = ctx->bufsz;
+
+    memset(ctx->buf + num, 0, bsz - num);
+    ctx->buf[num] = ctx->pad;
+    ctx->buf[bsz - 1] |= 0x80;
+
+    (void)ossl_keccak1600_p12_absorb(ctx->A, ctx->buf, bsz, bsz);
+    ossl_keccak1600_p12_squeeze(ctx->A, out, outlen, bsz, 0);
+    return 1;
+}
+
+static int turboshake_squeeze_p12(KECCAK1600_CTX *ctx, unsigned char *out,
+    size_t outlen)
+{
+    return ossl_keccak_block_squeeze(ctx, out, outlen,
+        ossl_keccak1600_p12_absorb, ossl_keccak1600_p12_squeeze);
+}
+
+static PROV_SHA3_METHOD turboshake_p12_md = {
+    turboshake_absorb_p12,
+    turboshake_final_p12,
+    turboshake_squeeze_p12
+};
+
+int ossl_turboshake_init_keccak(KECCAK1600_CTX *ctx, size_t bitlen,
+    unsigned int domain, size_t xoflen)
+{
+    if (domain < TURBOSHAKE_DOMAIN_MIN || domain > TURBOSHAKE_DOMAIN_MAX)
+        return 0;
+    if (!ossl_sha3_init(ctx, (unsigned char)domain, bitlen))
+        return 0;
+    memset(ctx->A, 0, sizeof(ctx->A));
+    ctx->md_size = xoflen;
+    ctx->meth = turboshake_p12_md;
+    return 1;
+}
+
+static void *turboshake_newctx(ossl_unused void *provctx, size_t bitlen)
+{
+    TURBOSHAKE_CTX *ctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return NULL;
+    ctx = OPENSSL_zalloc(sizeof(*ctx));
+    if (ctx == NULL)
+        return NULL;
+    ctx->bitlen = bitlen;
+    if (!ossl_turboshake_init_keccak(&ctx->kctx, bitlen,
+            TURBOSHAKE_DOMAIN_DEFAULT, bitlen == 128 ? 32 : 64)) {
+        OPENSSL_clear_free(ctx, sizeof(*ctx));
+        return NULL;
+    }
+    return ctx;
+}
+
+static int turboshake_init(void *vctx, const OSSL_PARAM params[])
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    return ossl_turboshake_init_keccak(&ctx->kctx, ctx->bitlen,
+               TURBOSHAKE_DOMAIN_DEFAULT, ctx->bitlen == 128 ? 32 : 64)
+        && turboshake_set_ctx_params(vctx, params);
+}
+
+static int turboshake_update(void *vctx, const unsigned char *inp, size_t len)
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+
+    return ossl_sha3_absorb(&ctx->kctx, inp, len);
+}
+
+static int turboshake_final(void *vctx, unsigned char *out, size_t *outl,
+    size_t outsz)
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+    size_t xoflen = ctx->kctx.md_size;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    if (outsz < xoflen)
+        return 0;
+    if (xoflen > 0 && !ossl_sha3_final(&ctx->kctx, out, xoflen))
+        return 0;
+    if (outl != NULL)
+        *outl = xoflen;
+    return 1;
+}
+
+static int turboshake_squeeze(void *vctx, unsigned char *out, size_t *outl,
+    size_t outsz)
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+
+    if (ossl_unlikely(!ossl_prov_is_running()))
+        return 0;
+    if (outsz > 0 && !ossl_sha3_squeeze(&ctx->kctx, out, outsz))
+        return 0;
+    if (outl != NULL)
+        *outl = outsz;
+    return 1;
+}
+
+static void turboshake_freectx(void *vctx)
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+
+    OPENSSL_clear_free(ctx, sizeof(*ctx));
+}
+
+static void *turboshake_dupctx(void *vctx)
+{
+    TURBOSHAKE_CTX *in = vctx;
+    TURBOSHAKE_CTX *ret = ossl_prov_is_running() ? OPENSSL_malloc(sizeof(*ret))
+                                                 : NULL;
+
+    if (ret != NULL)
+        *ret = *in;
+    return ret;
+}
+
+static void turboshake_copyctx(void *voutctx, void *vinctx)
+{
+    TURBOSHAKE_CTX *outctx = voutctx;
+    TURBOSHAKE_CTX *inctx = vinctx;
+
+    *outctx = *inctx;
+}
+
+static const OSSL_PARAM *turboshake_gettable_ctx_params(
+    ossl_unused void *ctx, ossl_unused void *provctx)
+{
+    return turboshake_get_ctx_params_list;
+}
+
+static int turboshake_get_ctx_params(void *vctx, OSSL_PARAM params[])
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+    struct turboshake_get_ctx_params_st p;
+    size_t xoflen;
+    unsigned int domain;
+
+    if (ctx == NULL || !turboshake_get_ctx_params_decoder(params, &p))
+        return 0;
+
+    xoflen = ctx->kctx.md_size;
+    if (p.size != NULL && !OSSL_PARAM_set_size_t(p.size, xoflen)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    if (p.xoflen != NULL && !OSSL_PARAM_set_size_t(p.xoflen, xoflen)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    domain = ctx->kctx.pad;
+    if (p.domain != NULL && !OSSL_PARAM_set_uint(p.domain, domain)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    return 1;
+}
+
+static const OSSL_PARAM *turboshake_settable_ctx_params(
+    ossl_unused void *ctx, ossl_unused void *provctx)
+{
+    return turboshake_set_ctx_params_list;
+}
+
+static int turboshake_set_ctx_params(void *vctx, const OSSL_PARAM params[])
+{
+    TURBOSHAKE_CTX *ctx = vctx;
+    struct turboshake_set_ctx_params_st p;
+    int has_change = 0;
+
+    if (ctx == NULL || !turboshake_set_ctx_params_decoder(params, &p))
+        return 0;
+
+    has_change = p.xoflen != NULL || p.domain != NULL;
+    if (has_change && (ctx->kctx.xof_state == XOF_STATE_FINAL || ctx->kctx.xof_state == XOF_STATE_SQUEEZE))
+        return 0;
+
+    if (p.xoflen != NULL
+        && !OSSL_PARAM_get_size_t(p.xoflen, &ctx->kctx.md_size)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
+    }
+    if (p.domain != NULL) {
+        unsigned int domain;
+
+        if (!OSSL_PARAM_get_uint(p.domain, &domain)) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+            return 0;
+        }
+        if (domain < TURBOSHAKE_DOMAIN_MIN || domain > TURBOSHAKE_DOMAIN_MAX) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_VALUE_ERROR);
+            return 0;
+        }
+        ctx->kctx.pad = (unsigned char)domain;
+    }
+    return 1;
+}
+
+#define IMPLEMENT_TURBOSHAKE(bitlen)                                                    \
+    static OSSL_FUNC_digest_newctx_fn turboshake_##bitlen##_newctx;                     \
+    static void *turboshake_##bitlen##_newctx(void *provctx)                            \
+    {                                                                                   \
+        return turboshake_newctx(provctx, bitlen);                                      \
+    }                                                                                   \
+    PROV_FUNC_DIGEST_GET_PARAM(turboshake_##bitlen, SHA3_BLOCKSIZE(bitlen),             \
+        bitlen == 128 ? 32 : 64, TURBOSHAKE_FLAGS)                                      \
+    const OSSL_DISPATCH ossl_turboshake_##bitlen##_functions[] = {                      \
+        { OSSL_FUNC_DIGEST_NEWCTX, (void (*)(void))turboshake_##bitlen##_newctx },      \
+        { OSSL_FUNC_DIGEST_INIT, (void (*)(void))turboshake_init },                     \
+        { OSSL_FUNC_DIGEST_UPDATE, (void (*)(void))turboshake_update },                 \
+        { OSSL_FUNC_DIGEST_FINAL, (void (*)(void))turboshake_final },                   \
+        { OSSL_FUNC_DIGEST_SQUEEZE, (void (*)(void))turboshake_squeeze },               \
+        { OSSL_FUNC_DIGEST_FREECTX, (void (*)(void))turboshake_freectx },               \
+        { OSSL_FUNC_DIGEST_DUPCTX, (void (*)(void))turboshake_dupctx },                 \
+        { OSSL_FUNC_DIGEST_COPYCTX, (void (*)(void))turboshake_copyctx },               \
+        { OSSL_FUNC_DIGEST_SET_CTX_PARAMS, (void (*)(void))turboshake_set_ctx_params }, \
+        { OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS,                                         \
+            (void (*)(void))turboshake_settable_ctx_params },                           \
+        { OSSL_FUNC_DIGEST_GET_CTX_PARAMS, (void (*)(void))turboshake_get_ctx_params }, \
+        { OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS,                                         \
+            (void (*)(void))turboshake_gettable_ctx_params },                           \
+        PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(turboshake_##bitlen),                      \
+        PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END
+
+/* ossl_turboshake_128_functions */
+IMPLEMENT_TURBOSHAKE(128)
+/* ossl_turboshake_256_functions */
+IMPLEMENT_TURBOSHAKE(256)
diff --git a/providers/implementations/digests/turboshake_prov.h b/providers/implementations/digests/turboshake_prov.h
new file mode 100644
index 0000000000..6830544487
--- /dev/null
+++ b/providers/implementations/digests/turboshake_prov.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OSSL_PROVIDERS_IMPLEMENTATIONS_DIGESTS_TURBOSHAKE_PROV_H
+#define OSSL_PROVIDERS_IMPLEMENTATIONS_DIGESTS_TURBOSHAKE_PROV_H
+
+#include "internal/sha3.h"
+
+/**
+ * @brief Initialize a Keccak sponge for TurboSHAKE or KangarooTwelve.
+ *
+ * Resets the state and installs the Keccak-p[1600,12] methods.
+ *
+ * @param ctx sponge context to initialize
+ * @param bitlen security strength in bits, 128 or 256
+ * @param domain domain separation byte, from 1 to 127 inclusive
+ * @param xoflen default output length in bytes
+ * @returns 1 on success, or 0 on an invalid domain or initialization failure
+ */
+int ossl_turboshake_init_keccak(KECCAK1600_CTX *ctx, size_t bitlen,
+    unsigned int domain, size_t xoflen);
+
+#endif
diff --git a/providers/implementations/digests/turboshake_prov.inc.in b/providers/implementations/digests/turboshake_prov.inc.in
new file mode 100644
index 0000000000..4292df5c00
--- /dev/null
+++ b/providers/implementations/digests/turboshake_prov.inc.in
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+{-
+use OpenSSL::paramnames qw(produce_param_decoder);
+-}
+
+{- produce_param_decoder('turboshake_get_ctx_params',
+                         (['OSSL_DIGEST_PARAM_XOFLEN',   'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_SIZE',     'size',     'size_t'],
+                          ['OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR', 'domain', 'uint'],
+                         )); -}
+
+{- produce_param_decoder('turboshake_set_ctx_params',
+                         (['OSSL_DIGEST_PARAM_XOFLEN',   'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_SIZE',     'xoflen',   'size_t'],
+                          ['OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR', 'domain', 'uint'],
+                         )); -}
diff --git a/providers/implementations/include/prov/implementations.h b/providers/implementations/include/prov/implementations.h
index 1a758ce8a6..58e0097b27 100644
--- a/providers/implementations/include/prov/implementations.h
+++ b/providers/implementations/include/prov/implementations.h
@@ -36,6 +36,10 @@ extern const OSSL_DISPATCH ossl_cshake_keccak_128_functions[];
 extern const OSSL_DISPATCH ossl_cshake_keccak_256_functions[];
 extern const OSSL_DISPATCH ossl_cshake_128_functions[];
 extern const OSSL_DISPATCH ossl_cshake_256_functions[];
+extern const OSSL_DISPATCH ossl_turboshake_128_functions[];
+extern const OSSL_DISPATCH ossl_turboshake_256_functions[];
+extern const OSSL_DISPATCH ossl_kt_128_functions[];
+extern const OSSL_DISPATCH ossl_kt_256_functions[];
 extern const OSSL_DISPATCH ossl_blake2s256_functions[];
 extern const OSSL_DISPATCH ossl_blake2b512_functions[];
 extern const OSSL_DISPATCH ossl_md5_functions[];
diff --git a/providers/implementations/include/prov/names.h b/providers/implementations/include/prov/names.h
index f08d1411d2..2036fca81e 100644
--- a/providers/implementations/include/prov/names.h
+++ b/providers/implementations/include/prov/names.h
@@ -260,6 +260,11 @@
 #define PROV_NAMES_CSHAKE_KECCAK_256 "CSHAKE-KECCAK-256:KECCAK-KMAC-256:KECCAK-KMAC256"
 #define PROV_NAMES_KECCAK_KMAC_128 PROV_NAMES_CSHAKE_KECCAK_128
 #define PROV_NAMES_KECCAK_KMAC_256 PROV_NAMES_CSHAKE_KECCAK_256
+
+#define PROV_NAMES_TURBOSHAKE_128 "TURBOSHAKE-128:TURBOSHAKE128"
+#define PROV_NAMES_TURBOSHAKE_256 "TURBOSHAKE-256:TURBOSHAKE256"
+#define PROV_NAMES_KT_128 "KT-128:KT128"
+#define PROV_NAMES_KT_256 "KT-256:KT256"
 /*
  * https://blake2.net/ doesn't specify size variants, but mentions that
  * Bouncy Castle uses the names BLAKE2b-160, BLAKE2b-256, BLAKE2b-384, and
diff --git a/test/evp_test.c b/test/evp_test.c
index eb3502e847..2357422bc1 100644
--- a/test/evp_test.c
+++ b/test/evp_test.c
@@ -5904,6 +5904,10 @@ static int is_digest_disabled(const char *name)
     if (HAS_CASE_PREFIX(name, "BLAKE"))
         return 1;
 #endif
+#ifdef OPENSSL_NO_KT
+    if (HAS_CASE_PREFIX(name, "KT"))
+        return 1;
+#endif
 #ifdef OPENSSL_NO_MD2
     if (OPENSSL_strcasecmp(name, "MD2") == 0)
         return 1;
@@ -5928,6 +5932,10 @@ static int is_digest_disabled(const char *name)
     if (OPENSSL_strcasecmp(name, "SM3") == 0)
         return 1;
 #endif
+#ifdef OPENSSL_NO_TURBOSHAKE
+    if (HAS_CASE_PREFIX(name, "TURBOSHAKE"))
+        return 1;
+#endif
 #ifdef OPENSSL_NO_WHIRLPOOL
     if (OPENSSL_strcasecmp(name, "WHIRLPOOL") == 0)
         return 1;
diff --git a/test/evp_xof_test.c b/test/evp_xof_test.c
index 57f19982b7..4efd6e6b1e 100644
--- a/test/evp_xof_test.c
+++ b/test/evp_xof_test.c
@@ -7,12 +7,20 @@
  * https://www.openssl.org/source/license.html
  */

+#include <stdint.h>
+#include <string.h>
 #include <openssl/evp.h>
+#include <openssl/err.h>
+#include <openssl/crypto.h>
+#include <openssl/provider.h>
 #include <openssl/rand.h>
 #include <openssl/core_names.h>
 #include "testutil.h"
 #include "internal/nelem.h"

+static OSSL_LIB_CTX *fips_libctx = NULL;
+static OSSL_PROVIDER *nullprov = NULL, *fipsprov = NULL;
+
 static const uint8_t shake256_input[] = {
     0x8d, 0x80, 0x01, 0xe2, 0xc0, 0x96, 0xf1, 0xb8,
     0x8e, 0x7c, 0x92, 0x24, 0xa0, 0x86, 0xef, 0xd4,
@@ -74,6 +82,58 @@ static const uint8_t cshake256_output[] = {
     0x4a, 0xa8, 0x70, 0xe7, 0x61, 0x6b, 0x0c, 0x3c
 };

+#if !defined(OPENSSL_NO_TURBOSHAKE) || !defined(OPENSSL_NO_KT)
+static const uint8_t empty_input[1] = { 0 };
+#endif
+
+#ifndef OPENSSL_NO_TURBOSHAKE
+static const uint8_t turboshake128_empty_output[] = {
+    0x1e, 0x41, 0x5f, 0x1c, 0x59, 0x83, 0xaf, 0xf2,
+    0x16, 0x92, 0x17, 0x27, 0x7d, 0x17, 0xbb, 0x53,
+    0x8c, 0xd9, 0x45, 0xa3, 0x97, 0xdd, 0xec, 0x54,
+    0x1f, 0x1c, 0xe4, 0x1a, 0xf2, 0xc1, 0xb7, 0x4c,
+    0x3e, 0x8c, 0xca, 0xe2, 0xa4, 0xda, 0xe5, 0x6c,
+    0x84, 0xa0, 0x4c, 0x23, 0x85, 0xc0, 0x3c, 0x15,
+    0xe8, 0x19, 0x3b, 0xdf, 0x58, 0x73, 0x73, 0x63,
+    0x32, 0x16, 0x91, 0xc0, 0x54, 0x62, 0xc8, 0xdf
+};
+
+static const uint8_t turboshake256_empty_output[] = {
+    0x36, 0x7a, 0x32, 0x9d, 0xaf, 0xea, 0x87, 0x1c,
+    0x78, 0x02, 0xec, 0x67, 0xf9, 0x05, 0xae, 0x13,
+    0xc5, 0x76, 0x95, 0xdc, 0x2c, 0x66, 0x63, 0xc6,
+    0x10, 0x35, 0xf5, 0x9a, 0x18, 0xf8, 0xe7, 0xdb,
+    0x11, 0xed, 0xc0, 0xe1, 0x2e, 0x91, 0xea, 0x60,
+    0xeb, 0x6b, 0x32, 0xdf, 0x06, 0xdd, 0x7f, 0x00,
+    0x2f, 0xba, 0xfa, 0xbb, 0x6e, 0x13, 0xec, 0x1c,
+    0xc2, 0x0d, 0x99, 0x55, 0x47, 0x60, 0x0d, 0xb0
+};
+#endif
+
+#ifndef OPENSSL_NO_KT
+static const uint8_t kt128_empty_output[] = {
+    0x1a, 0xc2, 0xd4, 0x50, 0xfc, 0x3b, 0x42, 0x05,
+    0xd1, 0x9d, 0xa7, 0xbf, 0xca, 0x1b, 0x37, 0x51,
+    0x3c, 0x08, 0x03, 0x57, 0x7a, 0xc7, 0x16, 0x7f,
+    0x06, 0xfe, 0x2c, 0xe1, 0xf0, 0xef, 0x39, 0xe5,
+    0x42, 0x69, 0xc0, 0x56, 0xb8, 0xc8, 0x2e, 0x48,
+    0x27, 0x60, 0x38, 0xb6, 0xd2, 0x92, 0x96, 0x6c,
+    0xc0, 0x7a, 0x3d, 0x46, 0x45, 0x27, 0x2e, 0x31,
+    0xff, 0x38, 0x50, 0x81, 0x39, 0xeb, 0x0a, 0x71
+};
+
+static const uint8_t kt256_empty_output[] = {
+    0xb2, 0x3d, 0x2e, 0x9c, 0xea, 0x9f, 0x49, 0x04,
+    0xe0, 0x2b, 0xec, 0x06, 0x81, 0x7f, 0xc1, 0x0c,
+    0xe3, 0x8c, 0xe8, 0xe9, 0x3e, 0xf4, 0xc8, 0x9e,
+    0x65, 0x37, 0x07, 0x6a, 0xf8, 0x64, 0x64, 0x04,
+    0xe3, 0xe8, 0xb6, 0x81, 0x07, 0xb8, 0x83, 0x3a,
+    0x5d, 0x30, 0x49, 0x0a, 0xa3, 0x34, 0x82, 0x35,
+    0x3f, 0xd4, 0xad, 0xc7, 0x14, 0x8e, 0xcb, 0x78,
+    0x28, 0x55, 0x00, 0x3a, 0xae, 0xbd, 0xe4, 0xa9
+};
+#endif
+
 typedef struct test_data_st {
     const char *alg;
     const uint8_t *in;
@@ -103,6 +163,26 @@ static const TEST_DATA xof_test_data[] = {
         64,
         "KMAC",
         "Custom" },
+#ifndef OPENSSL_NO_TURBOSHAKE
+    { "TURBOSHAKE128",
+        empty_input, 0,
+        turboshake128_empty_output, sizeof(turboshake128_empty_output),
+        32 },
+    { "TURBOSHAKE256",
+        empty_input, 0,
+        turboshake256_empty_output, sizeof(turboshake256_empty_output),
+        64 },
+#endif
+#ifndef OPENSSL_NO_KT
+    { "KT128",
+        empty_input, 0,
+        kt128_empty_output, sizeof(kt128_empty_output),
+        32 },
+    { "KT256",
+        empty_input, 0,
+        kt256_empty_output, sizeof(kt256_empty_output),
+        64 },
+#endif
 };

 static const unsigned char shake256_largemsg_input[] = {
@@ -613,6 +693,1007 @@ err:
     return ret;
 }

+#if !defined(OPENSSL_NO_TURBOSHAKE) || !defined(OPENSSL_NO_KT)
+static void fill_ptn(unsigned char *buf, size_t len)
+{
+    size_t i;
+
+    for (i = 0; i < len; i++)
+        buf[i] = (unsigned char)(i % 251);
+}
+#endif
+
+#ifndef OPENSSL_NO_TURBOSHAKE
+typedef struct turboshake_squeeze_data_st {
+    const char *alg;
+    size_t rate;
+} TURBOSHAKE_SQUEEZE_DATA;
+
+static const TURBOSHAKE_SQUEEZE_DATA turboshake_squeeze_tests[] = {
+    { "TURBOSHAKE128", 168 },
+    { "TURBOSHAKE256", 136 },
+};
+
+static int turboshake_segmented_squeeze_test(int tstid)
+{
+    const TURBOSHAKE_SQUEEZE_DATA *td = turboshake_squeeze_tests + tstid;
+    unsigned char msg[257];
+    unsigned char expected[3 * 168], segmented[3 * 168];
+    size_t i, split, outlen = 3 * td->rate;
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    fill_ptn(msg, sizeof(msg));
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, td->alg, NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, NULL))
+        || !TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
+        || !TEST_true(EVP_DigestFinalXOF(ctx, expected, outlen)))
+        goto err;
+
+    for (i = 0; i < 3; i++) {
+        split = td->rate - 1 + i;
+        if (!TEST_true(EVP_DigestInit_ex2(ctx, md, NULL))
+            || !TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
+            || !TEST_true(EVP_DigestSqueeze(ctx, segmented, split))
+            || !TEST_true(EVP_DigestSqueeze(ctx, segmented + split,
+                outlen - split))
+            || !TEST_mem_eq(segmented, outlen, expected, outlen))
+            goto err;
+    }
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+#endif
+
+static int digest_xof_with_params_ex(OSSL_LIB_CTX *libctx, const char *propq,
+    const char *alg, const unsigned char *in, size_t inlen,
+    const OSSL_PARAM params[], unsigned char *out, size_t outlen)
+{
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(libctx, alg, propq))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, params))
+        || !TEST_true(EVP_DigestUpdate(ctx, in, inlen))
+        || !TEST_true(EVP_DigestFinalXOF(ctx, out, outlen)))
+        goto err;
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+#if !defined(OPENSSL_NO_TURBOSHAKE) || !defined(OPENSSL_NO_KT)
+static int digest_xof_with_params(const char *alg, const unsigned char *in,
+    size_t inlen, const OSSL_PARAM params[], unsigned char *out, size_t outlen)
+{
+    return digest_xof_with_params_ex(NULL, NULL, alg, in, inlen, params, out,
+        outlen);
+}
+
+static int digest_xof_chunked_with_params(const char *alg,
+    const unsigned char *in, size_t inlen, const OSSL_PARAM params[],
+    unsigned char *out, size_t outlen)
+{
+    static const size_t chunks[] = { 1, 7, 136, 168, 8191, 3, 257 };
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    size_t i = 0, off = 0, len;
+    int ret = 0;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, alg, NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, params)))
+        goto err;
+
+    while (off < inlen) {
+        len = chunks[i++ % OSSL_NELEM(chunks)];
+        if (len > inlen - off)
+            len = inlen - off;
+        if (!TEST_true(EVP_DigestUpdate(ctx, in + off, len)))
+            goto err;
+        off += len;
+    }
+
+    if (!TEST_true(EVP_DigestFinalXOF(ctx, out, outlen)))
+        goto err;
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+typedef struct turboshake_kt_data_st {
+    const char *alg;
+    int is_kt;
+    size_t outlen;
+} TURBOSHAKE_KT_DATA;
+
+static const TURBOSHAKE_KT_DATA turboshake_kt_tests[] = {
+#ifndef OPENSSL_NO_TURBOSHAKE
+    { "TURBOSHAKE128", 0, 32 },
+    { "TURBOSHAKE256", 0, 64 },
+#endif
+#ifndef OPENSSL_NO_KT
+    { "KT128", 1, 32 },
+    { "KT256", 1, 64 },
+#endif
+};
+
+static int turboshake_kt_chunked_absorb_and_size_test(int tstid)
+{
+    const TURBOSHAKE_KT_DATA *td = turboshake_kt_tests + tstid;
+    unsigned char *msg = NULL, *one_shot = NULL, *chunked = NULL, *noop = NULL;
+    unsigned char custom[41], z = 0;
+    unsigned int domain = 2;
+    size_t msglen = 9005, outlen = td->outlen;
+    OSSL_PARAM params[4], *p = params;
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    if (!TEST_ptr(msg = OPENSSL_malloc(msglen))
+        || !TEST_ptr(one_shot = OPENSSL_malloc(outlen))
+        || !TEST_ptr(chunked = OPENSSL_malloc(outlen))
+        || !TEST_ptr(noop = OPENSSL_malloc(outlen)))
+        goto err;
+    fill_ptn(msg, msglen);
+    fill_ptn(custom, sizeof(custom));
+
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_SIZE, &outlen);
+    if (td->is_kt) {
+        *p++ = OSSL_PARAM_construct_octet_string(
+            OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom));
+    } else {
+        *p++ = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+            &domain);
+    }
+    *p = OSSL_PARAM_construct_end();
+
+    if (!digest_xof_with_params(td->alg, msg, msglen, params, one_shot, outlen)
+        || !digest_xof_chunked_with_params(td->alg, msg, msglen, params,
+            chunked, outlen)
+        || !TEST_mem_eq(chunked, outlen, one_shot, outlen))
+        goto err;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, td->alg, NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, NULL))
+        || !TEST_true(EVP_DigestSqueeze(ctx, &z, 0))
+        || !TEST_true(EVP_MD_CTX_set_params(ctx, params))
+        || !TEST_true(EVP_DigestUpdate(ctx, msg, msglen))
+        || !TEST_true(EVP_DigestFinalXOF(ctx, noop, outlen))
+        || !TEST_mem_eq(noop, outlen, one_shot, outlen))
+        goto err;
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    OPENSSL_free(noop);
+    OPENSSL_free(chunked);
+    OPENSSL_free(one_shot);
+    OPENSSL_free(msg);
+    return ret;
+}
+
+static int turboshake_kt_copyctx_test(int tstid)
+{
+    const TURBOSHAKE_KT_DATA *td = turboshake_kt_tests + tstid;
+    unsigned char msg[257], expected[64], copied[64];
+    unsigned char custom[41];
+    unsigned int domain = 3;
+    size_t outlen = td->outlen;
+    OSSL_PARAM params[4], *p = params;
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL, *copy = NULL;
+    int ret = 0;
+
+    fill_ptn(msg, sizeof(msg));
+    fill_ptn(custom, sizeof(custom));
+
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &outlen);
+    if (td->is_kt) {
+        *p++ = OSSL_PARAM_construct_octet_string(
+            OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom));
+    } else {
+        *p++ = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+            &domain);
+    }
+    *p = OSSL_PARAM_construct_end();
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, td->alg, NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_ptr(copy = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, params))
+        || !TEST_true(EVP_DigestInit_ex2(copy, md, params))
+        || !TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
+        || !TEST_true(EVP_MD_CTX_copy_ex(copy, ctx))
+        || !TEST_true(EVP_DigestFinalXOF(ctx, expected, outlen))
+        || !TEST_true(EVP_DigestFinalXOF(copy, copied, outlen))
+        || !TEST_mem_eq(copied, outlen, expected, outlen))
+        goto err;
+    ret = 1;
+err:
+    EVP_MD_CTX_free(copy);
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+static int turboshake_kt_xoflen_alias_conflict_test(int tstid)
+{
+    const TURBOSHAKE_KT_DATA *td = turboshake_kt_tests + tstid;
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    size_t xoflen = td->outlen, size = td->outlen;
+    OSSL_PARAM params[3];
+    int i, ret = 0;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, td->alg, NULL)))
+        goto err;
+
+    for (i = 0; i < 2; i++) {
+        if (!TEST_ptr(ctx = EVP_MD_CTX_new()))
+            goto err;
+        if (i == 0) {
+            params[0] = OSSL_PARAM_construct_size_t(
+                OSSL_DIGEST_PARAM_XOFLEN, &xoflen);
+            params[1] = OSSL_PARAM_construct_size_t(
+                OSSL_DIGEST_PARAM_SIZE, &size);
+        } else {
+            params[0] = OSSL_PARAM_construct_size_t(
+                OSSL_DIGEST_PARAM_SIZE, &size);
+            params[1] = OSSL_PARAM_construct_size_t(
+                OSSL_DIGEST_PARAM_XOFLEN, &xoflen);
+        }
+        params[2] = OSSL_PARAM_construct_end();
+
+        ERR_set_mark();
+        if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+            ERR_clear_last_mark();
+            goto err;
+        }
+        ERR_pop_to_mark();
+        EVP_MD_CTX_free(ctx);
+        ctx = NULL;
+    }
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+#ifndef OPENSSL_NO_TURBOSHAKE
+static int turboshake_repeated_param_test(void)
+{
+    unsigned int domain1 = 1, domain2 = 2;
+    OSSL_PARAM params[3];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "TURBOSHAKE128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_uint(
+        OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR, &domain1);
+    params[1] = OSSL_PARAM_construct_uint(
+        OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR, &domain2);
+    params[2] = OSSL_PARAM_construct_end();
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+#endif
+
+#ifndef OPENSSL_NO_KT
+static int kt_repeated_param_test(void)
+{
+    static char custom_utf8[] = "Custom";
+    static unsigned char custom_octet[] = {
+        'C', 'u', 's', 't', 'o', 'm'
+    };
+    OSSL_PARAM params[3];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "KT128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom_utf8, 0);
+    params[1] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom_octet, sizeof(custom_octet));
+    params[2] = OSSL_PARAM_construct_end();
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+#endif
+
+#define TURBOSHAKE_KT_NO_CUSTOM SIZE_MAX
+
+typedef enum turboshake_kt_input_kind_e {
+    TURBOSHAKE_KT_INPUT_EMPTY,
+    TURBOSHAKE_KT_INPUT_HEX,
+    TURBOSHAKE_KT_INPUT_PTN
+} TURBOSHAKE_KT_INPUT_KIND;
+
+typedef struct turboshake_kt_vector_st {
+    const char *alg;
+    TURBOSHAKE_KT_INPUT_KIND input_kind;
+    size_t input_len;
+    const char *input_hex;
+    size_t outlen;
+    const char *expected_hex;
+    int has_domain;
+    unsigned int domain;
+    size_t custom_len;
+    int suffix_only;
+} TURBOSHAKE_KT_VECTOR;
+
+/*
+ * The TurboSHAKE and KangarooTwelve test vectors in this table are from
+ * RFC 9861.
+ */
+static const TURBOSHAKE_KT_VECTOR turboshake_kt_vectors[] = {
+#ifndef OPENSSL_NO_TURBOSHAKE
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 1, NULL, 32,
+        "55cedd6f60af7bb29a4042ae832ef3f58db7299f893ebb9247247d856958daa9", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 17, NULL, 32,
+        "9c97d036a3bac819db70ede0ca554ec6e4c2a1a4ffbfd9ec269ca6a111161233", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 289, NULL, 32,
+        "96c77c279e0126f7fc07c9b07f5cdae1e0be60bdbe10620040e75d7223a624d2", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 4913, NULL, 32,
+        "d4976eb56bcf118520582b709f73e1d6853e001fdaf80e1b13e0d0599d5fb372", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 83521, NULL, 32,
+        "da67c7039e98bf530cf7a37830c6664e14cbab7f540f58403b1b82951318ee5c", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 1419857, NULL, 32,
+        "b97a906fbf83ef7c812517abf3b2d0aea0c4f60318ce11cf103925127f59eecd", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_PTN, 24137569, NULL, 32,
+        "35cd494adeded2f25239af09a7b8ef0c4d1ca4fe2d1ac370fa63216fe7b4c2b1", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 1, NULL, 64,
+        "3e1712f928f8eaf1054632b2aa0a246ed8b0c378728f60bc970410155c28820e90cc90d8a3006aa2372c5c5ea176b0682bf22bae7467ac94f74d43d39b0482e2", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 17, NULL, 64,
+        "b3bab0300e6a191fbe6137939835923578794ea54843f5011090fa2f3780a9e5cb22c59d78b40a0fbff9e672c0fbe0970bd2c845091c6044d687054da5d8e9c7", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 289, NULL, 64,
+        "66b810db8e90780424c0847372fdc95710882fde31c6df75beb9d4cd9305cfcae35e7b83e8b7e6eb4b78605880116316fe2c078a09b94ad7b8213c0a738b65c0", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 4913, NULL, 64,
+        "c74ebc919a5b3b0dd1228185ba02d29ef442d69d3d4276a93efe0bf9a16a7dc0cd4eabadab8cd7a5edd96695f5d360abe09e2c6511a3ec397da3b76b9e1674fb", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 83521, NULL, 64,
+        "02cc3a8897e6f4f6ccb6fd46631b1f5207b66c6de9c7b55b2d1a23134a170afdac234eaba9a77cff88c1f020b73724618c5687b362c430b248cd38647f848a1d", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 1419857, NULL, 64,
+        "add53b06543e584b5823f626996aee50fe45ed15f20243a7165485acb4aa76b4ffda75cedf6d8cdc95c332bd56f4b986b58bb17d1778bfc1b1a97545cdf4ec9f", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_PTN, 24137569, NULL, 64,
+        "9e11bc59c24e73993c1484ec66358ef71db74aefd84e123f7800ba9c4853e02cfe701d9e6bb765a304f0dc34a4ee3ba82c410f0da70e86bfbd90ea877c2d6104", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+#endif
+#ifndef OPENSSL_NO_KT
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 1, NULL, 32,
+        "2bda92450e8b147f8a7cb629e784a058efca7cf7d8218e02d345dfaa65244a1f", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 17, NULL, 32,
+        "6bf75fa2239198db4772e36478f8e19b0f371205f6a9a93a273f51df37122888", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 289, NULL, 32,
+        "0c315ebcdedbf61426de7dcf8fb725d1e74675d7f5327a5067f367b108ecb67c", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 4913, NULL, 32,
+        "cb552e2ec77d9910701d578b457ddf772c12e322e4ee7fe417f92c758f0d59d0", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 83521, NULL, 32,
+        "8701045e22205345ff4dda05555cbb5c3af1a771c2b89baef37db43d9998b9fe", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 1419857, NULL, 32,
+        "844d610933b1b9963cbdeb5ae3b6b05cc7cbd67ceedf883eb678a0a8e0371682", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 24137569, NULL, 32,
+        "3c390782a8a4e89fa6367f72feaaf13255c8d95878481d3cd8ce85f58e880af8", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 32,
+        "fab658db63e94a246188bf7af69a133045f46ee984c56e3c3328caaf1aa1a583", 0, 0, 1, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_HEX, 0, "ff", 32,
+        "d848c5068ced736f4462159b9867fd4c20b808acc3d5bc48e0b06ba0a3762ec4", 0, 0, 41, 0 },
+#if 0
+    /*
+     * These RFC 9861 vectors use customization strings longer than OpenSSL's
+     * provider limit of 512 bytes, matching CSHAKE.
+     */
+    { "KT128", TURBOSHAKE_KT_INPUT_HEX, 0, "ffffff", 32,
+        "c389e5009ae57120854c2e8c64670ac01358cf4c1baf89447a724234dc7ced74", 0, 0, 1681, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_HEX, 0, "ffffffffffffff", 32,
+        "75d2f86a2e644566726b4fbcfc5657b9dbcf070c7b0dca06450ab291d7443bcf", 0, 0, 68921, 0 },
+#endif
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 8191, NULL, 32,
+        "1b577636f723643e990cc7d6a659837436fd6a103626600eb8301cd1dbe553d6", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 32,
+        "48f256f6772f9edfb6a8b661ec92dc93b95ebd05a08a17b39ae3490870c926c3", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+#if 0
+    /*
+     * These RFC 9861 tree-boundary vectors use customization strings longer
+     * than OpenSSL's provider limit of 512 bytes, matching CSHAKE.
+     */
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 32,
+        "3ed12f70fb05ddb58689510ab3e4d23c6c6033849aa01e1d8c220a297fedcd0b", 0, 0, 8189, 0 },
+    { "KT128", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 32,
+        "6a7c1b6a5cd0d8c9ca943a4a216cc64604559a2ea45f78570a15253d67ba00ae", 0, 0, 8190, 0 },
+#endif
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 1, NULL, 64,
+        "0d005a194085360217128cf17f91e1f71314efa5564539d444912e3437efa17f82db6f6ffe76e781eaa068bce01f2bbf81eacb983d7230f2fb02834a21b1ddd0", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 17, NULL, 64,
+        "1ba3c02b1fc514474f06c8979978a9056c8483f4a1b63d0dccefe3a28a2f323e1cdcca40ebf006ac76ef0397152346837b1277d3e7faa9c9653b19075098527b", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 289, NULL, 64,
+        "de8ccbc63e0f133ebb4416814d4c66f691bbf8b6a61ec0a7700f836b086cb029d54f12ac7159472c72db118c35b4e6aa213c6562caaa9dcc518959e69b10f3ba", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 4913, NULL, 64,
+        "647efb49fe9d717500171b41e7f11bd491544443209997ce1c2530d15eb1ffbb598935ef954528ffc152b1e4d731ee2683680674365cd191d562bae753b84aa5", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 83521, NULL, 64,
+        "b06275d284cd1cf205bcbe57dccd3ec1ff6686e3ed15776383e1f2fa3c6ac8f08bf8a162829db1a44b2a43ff83dd89c3cf1ceb61ede659766d5ccf817a62ba8d", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 1419857, NULL, 64,
+        "9473831d76a4c7bf77ace45b59f1458b1673d64bcd877a7c66b2664aa6dd149e60eab71b5c2bab858c074ded81ddce2b4022b5215935c0d4d19bf511aeeb0772", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 24137569, NULL, 64,
+        "0652b740d78c5e1f7c8dcc1777097382768b7ff38f9a7a20f29f413bb1b3045b31a5578f568f911e09cf44746da84224a5266e96a4a535e871324e4f9c7004da", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 64,
+        "9280f5cc39b54a5a594ec63de0bb99371e4609d44bf845c2f5b8c316d72b159811f748f23e3fabbe5c3226ec96c62186df2d33e9df74c5069ceecbb4dd10eff6", 0, 0, 1, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_HEX, 0, "ff", 64,
+        "47ef96dd616f200937aa7847e34ec2feae8087e3761dc0f8c1a154f51dc9ccf845d7adbce57ff64b639722c6a1672e3bf5372d87e00aff89be97240756998853", 0, 0, 41, 0 },
+#if 0
+    /*
+     * These RFC 9861 vectors use customization strings longer than OpenSSL's
+     * provider limit of 512 bytes, matching CSHAKE.
+     */
+    { "KT256", TURBOSHAKE_KT_INPUT_HEX, 0, "ffffff", 64,
+        "3b48667a5051c5966c53c5d42b95de451e05584e7806e2fb765eda959074172cb438a9e91dde337c98e9c41bed94c4e0aef431d0b64ef2324f7932caa6f54969", 0, 0, 1681, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_HEX, 0, "ffffffffffffff", 64,
+        "e0911cc00025e1540831e266d94add9b98712142b80d2629e643aac4efaf5a3a30a88cbf4ac2a91a2432743054fbcc9897670e86ba8cec2fc2ace9c966369724", 0, 0, 68921, 0 },
+#endif
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 8191, NULL, 64,
+        "3081434d93a4108d8d8a3305b89682cebedc7ca4ea8a3ce869fbb73cbe4a58eef6f24de38ffc170514c70e7ab2d01f03812616e863d769afb3753193ba045b20", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 64,
+        "c6ee8e2ad3200c018ac87aaa031cdac22121b412d07dc6e0dccbb53423747e9a1c18834d99df596cf0cf4b8dfafb7bf02d139d0c9035725adc1a01b7230a41fa", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 0 },
+#if 0
+    /*
+     * These RFC 9861 tree-boundary vectors use customization strings longer
+     * than OpenSSL's provider limit of 512 bytes, matching CSHAKE.
+     */
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 64,
+        "74e47879f10a9c5d11bd2da7e194fe57e86378bf3c3f7448eff3c576a0f18c5caae0999979512090a7f348af4260d4de3c37f1ecaf8d2c2c96c1d16c64b12496", 0, 0, 8189, 0 },
+    { "KT256", TURBOSHAKE_KT_INPUT_PTN, 8192, NULL, 64,
+        "f4b5908b929ffe01e0f79ec2f21243d41a396b2e7303a6af1d6399cd6c7a0a2dd7c4f607e8277f9c9b1cb4ab9ddc59d4b92d1fc7558441f1832c3279a4241b8b", 0, 0, 8190, 0 },
+#endif
+#endif
+#ifndef OPENSSL_NO_TURBOSHAKE
+    { "TURBOSHAKE128", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 10032,
+        "a3b9b0385900ce761f22aed548e754da10a5242d62e8c658e3f3a923a7555607", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 1 },
+    { "TURBOSHAKE256", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 10032,
+        "abefa11630c661269249742685ec082f207265dccf2f43534e9c61ba0c9d1d75", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 1 },
+#endif
+#ifndef OPENSSL_NO_KT
+    { "KT128", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 10032,
+        "e8dc563642f7228c84684c898405d3a834799158c079b12880277a1d28e2ff6d", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 1 },
+    { "KT256", TURBOSHAKE_KT_INPUT_EMPTY, 0, NULL, 10064,
+        "ad4a1d718cf950506709a4c33396139b4449041fc79a05d68da35f1e453522e056c64fe94958e7085f2964888259b9932752f3ccd855288efee5fcbb8b563069", 0, 0, TURBOSHAKE_KT_NO_CUSTOM, 1 },
+#endif
+};
+
+static int turboshake_kt_vector_test(int tstid)
+{
+    const TURBOSHAKE_KT_VECTOR *td = turboshake_kt_vectors + tstid;
+    unsigned char *in = NULL, *custom = NULL, *expected = NULL, *out = NULL;
+    const unsigned char *cmp;
+    OSSL_PARAM params[3], *p = params;
+    long hexlen;
+    size_t inlen = 0, explen;
+    unsigned int domain = td->domain;
+    int ret = 0;
+
+    switch (td->input_kind) {
+    case TURBOSHAKE_KT_INPUT_EMPTY:
+        in = (unsigned char *)empty_input;
+        inlen = 0;
+        break;
+    case TURBOSHAKE_KT_INPUT_HEX:
+        if (!TEST_ptr(in = OPENSSL_hexstr2buf(td->input_hex, &hexlen))
+            || !TEST_long_ge(hexlen, 0))
+            goto err;
+        inlen = (size_t)hexlen;
+        break;
+    case TURBOSHAKE_KT_INPUT_PTN:
+        if (!TEST_ptr(in = OPENSSL_malloc(td->input_len)))
+            goto err;
+        fill_ptn(in, td->input_len);
+        inlen = td->input_len;
+        break;
+    }
+
+    if (!TEST_ptr(expected = OPENSSL_hexstr2buf(td->expected_hex, &hexlen))
+        || !TEST_long_gt(hexlen, 0))
+        goto err;
+    explen = (size_t)hexlen;
+    if ((!td->suffix_only && !TEST_size_t_eq(explen, td->outlen))
+        || (td->suffix_only && !TEST_size_t_le(explen, td->outlen))
+        || !TEST_ptr(out = OPENSSL_malloc(td->outlen)))
+        goto err;
+
+    if (td->has_domain)
+        *p++ = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+            &domain);
+    if (td->custom_len != TURBOSHAKE_KT_NO_CUSTOM) {
+        if (!TEST_ptr(custom = OPENSSL_malloc(td->custom_len)))
+            goto err;
+        fill_ptn(custom, td->custom_len);
+        *p++ = OSSL_PARAM_construct_octet_string(
+            OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, td->custom_len);
+    }
+    *p = OSSL_PARAM_construct_end();
+
+    cmp = td->suffix_only ? out + td->outlen - explen : out;
+    if (!digest_xof_with_params(td->alg, in, inlen, params, out, td->outlen)
+        || !TEST_mem_eq(cmp, explen, expected, explen))
+        goto err;
+    ret = 1;
+err:
+    if (td->input_kind != TURBOSHAKE_KT_INPUT_EMPTY)
+        OPENSSL_free(in);
+    OPENSSL_free(custom);
+    OPENSSL_free(expected);
+    OPENSSL_free(out);
+    return ret;
+}
+#endif
+
+#ifndef OPENSSL_NO_TURBOSHAKE
+static int turboshake_domain_test(void)
+{
+    static const unsigned char msg[] = { 0xff, 0xff, 0xff };
+    static const unsigned char expected[] = {
+        0xbf, 0x32, 0x3f, 0x94, 0x04, 0x94, 0xe8, 0x8e,
+        0xe1, 0xc5, 0x40, 0xfe, 0x66, 0x0b, 0xe8, 0xa0,
+        0xc9, 0x3f, 0x43, 0xd1, 0x5e, 0xc0, 0x06, 0x99,
+        0x84, 0x62, 0xfa, 0x99, 0x4e, 0xed, 0x5d, 0xab
+    };
+    unsigned int domain = 1, invalid = 0;
+    OSSL_PARAM params[2];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    unsigned char out[sizeof(expected)];
+    int ret = 0;
+
+    params[0] = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+        &domain);
+    params[1] = OSSL_PARAM_construct_end();
+    if (!digest_xof_with_params("TURBOSHAKE128", msg, sizeof(msg), params,
+            out, sizeof(out))
+        || !TEST_mem_eq(out, sizeof(out), expected, sizeof(expected)))
+        goto err;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "TURBOSHAKE128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+        &invalid);
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+
+    invalid = 128;
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+
+    if (!TEST_true(EVP_DigestInit_ex2(ctx, md, NULL))
+        || !TEST_true(EVP_DigestSqueeze(ctx, out, sizeof(out))))
+        goto err;
+    domain = 2;
+    params[0] = OSSL_PARAM_construct_uint(OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR,
+        &domain);
+    ERR_set_mark();
+    if (!TEST_false(EVP_MD_CTX_set_params(ctx, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+#endif
+
+#ifndef OPENSSL_NO_KT
+static int kt_custom_octet_test(void)
+{
+    static const unsigned char msg[] = { 0xff };
+    static const unsigned char expected[] = {
+        0xd8, 0x48, 0xc5, 0x06, 0x8c, 0xed, 0x73, 0x6f,
+        0x44, 0x62, 0x15, 0x9b, 0x98, 0x67, 0xfd, 0x4c,
+        0x20, 0xb8, 0x08, 0xac, 0xc3, 0xd5, 0xbc, 0x48,
+        0xe0, 0xb0, 0x6b, 0xa0, 0xa3, 0x76, 0x2e, 0xc4
+    };
+    unsigned char custom[41];
+    unsigned char out[sizeof(expected)];
+    OSSL_PARAM params[2];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    fill_ptn(custom, sizeof(custom));
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom));
+    params[1] = OSSL_PARAM_construct_end();
+    if (!digest_xof_with_params("KT128", msg, sizeof(msg), params, out,
+            sizeof(out))
+        || !TEST_mem_eq(out, sizeof(out), expected, sizeof(expected)))
+        goto err;
+
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "KT128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, NULL))
+        || !TEST_true(EVP_DigestSqueeze(ctx, out, sizeof(out))))
+        goto err;
+    ERR_set_mark();
+    if (!TEST_false(EVP_MD_CTX_set_params(ctx, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+static int kt_custom_null_octet_test(void)
+{
+    static const unsigned char msg[] = { 0xff };
+    static unsigned char custom[] = "Custom";
+    unsigned char default_out[32], reset_out[32];
+    OSSL_PARAM params[2];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    if (!digest_xof_with_params("KT128", msg, sizeof(msg), NULL, default_out,
+            sizeof(default_out)))
+        return 0;
+
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom) - 1);
+    params[1] = OSSL_PARAM_construct_end();
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "KT128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new())
+        || !TEST_true(EVP_DigestInit_ex2(ctx, md, params)))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, NULL, 0);
+    if (!TEST_true(EVP_MD_CTX_set_params(ctx, params))
+        || !TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
+        || !TEST_true(EVP_DigestFinalXOF(ctx, reset_out, sizeof(reset_out)))
+        || !TEST_mem_eq(reset_out, sizeof(reset_out), default_out,
+            sizeof(default_out)))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+static int kt_custom_limit_test(void)
+{
+    unsigned char custom[513], out[32];
+    OSSL_PARAM params[2];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    fill_ptn(custom, sizeof(custom));
+    if (!TEST_ptr(md = EVP_MD_fetch(NULL, "KT128", NULL))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom) - 1);
+    params[1] = OSSL_PARAM_construct_end();
+    if (!TEST_true(EVP_DigestInit_ex2(ctx, md, params))
+        || !TEST_true(EVP_DigestSqueeze(ctx, out, sizeof(out))))
+        goto err;
+
+    EVP_MD_CTX_free(ctx);
+    ctx = NULL;
+    if (!TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom));
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+#endif
+
+static int cshake_custom_utf8_test_libctx(OSSL_LIB_CTX *libctx,
+    const char *propq)
+{
+    static char function_name[] = "KMAC";
+    static char custom_ascii[] = "Custom";
+    unsigned char ascii_out[sizeof(cshake256_output)];
+    OSSL_PARAM params[3];
+
+    params[0] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_FUNCTION_NAME, function_name, 0);
+    params[1] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom_ascii, 0);
+    params[2] = OSSL_PARAM_construct_end();
+
+    return digest_xof_with_params_ex(libctx, propq, "CSHAKE256",
+               shake256_input, sizeof(shake256_input), params, ascii_out,
+               sizeof(ascii_out))
+        && TEST_mem_eq(ascii_out, sizeof(ascii_out), cshake256_output,
+            sizeof(cshake256_output));
+}
+
+static int cshake_custom_octet_rejected_test_libctx(OSSL_LIB_CTX *libctx,
+    const char *propq)
+{
+    static char function_name[] = "KMAC";
+    static const unsigned char custom[] = "Custom";
+    OSSL_PARAM params[3];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    params[0] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_FUNCTION_NAME, function_name, 0);
+    params[1] = OSSL_PARAM_construct_octet_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, (void *)custom,
+        sizeof(custom) - 1);
+    params[2] = OSSL_PARAM_construct_end();
+
+    if (!TEST_ptr(md = EVP_MD_fetch(libctx, "CSHAKE256", propq))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    ERR_set_mark();
+    if (!TEST_false(EVP_DigestInit_ex2(ctx, md, params))) {
+        ERR_clear_last_mark();
+        goto err;
+    }
+    ERR_pop_to_mark();
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+static int cshake_custom_limit_test_libctx(OSSL_LIB_CTX *libctx,
+    const char *propq)
+{
+    static char function_name[] = "KMAC";
+    char custom[513];
+    unsigned char out[32];
+    OSSL_PARAM params[3];
+    EVP_MD *md = NULL;
+    EVP_MD_CTX *ctx = NULL;
+    int ret = 0;
+
+    memset(custom, 'C', sizeof(custom) - 1);
+    custom[sizeof(custom) - 1] = '\0';
+    if (!TEST_ptr(md = EVP_MD_fetch(libctx, "CSHAKE256", propq))
+        || !TEST_ptr(ctx = EVP_MD_CTX_new()))
+        goto err;
+
+    params[0] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_FUNCTION_NAME, function_name, 0);
+    params[1] = OSSL_PARAM_construct_utf8_string(
+        OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, sizeof(custom) - 1);
+    params[2] = OSSL_PARAM_construct_end();
+    if (!TEST_true(EVP_DigestInit_ex2(ctx, md, params))
+        || !TEST_true(EVP_DigestSqueeze(ctx, out, sizeof(out))))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_MD_CTX_free(ctx);
+    EVP_MD_free(md);
+    return ret;
+}
+
+static int cshake_custom_test(void)
+{
+    return cshake_custom_utf8_test_libctx(NULL, "provider=default")
+        && cshake_custom_octet_rejected_test_libctx(NULL, "provider=default")
+        && cshake_custom_limit_test_libctx(NULL, "provider=default");
+}
+
+static int cshake_custom_fips_test(void)
+{
+    return cshake_custom_utf8_test_libctx(fips_libctx, "fips=yes")
+        && cshake_custom_octet_rejected_test_libctx(fips_libctx, "fips=yes")
+        && cshake_custom_limit_test_libctx(fips_libctx, "fips=yes");
+}
+
+#ifndef OPENSSL_NO_KT
+typedef struct kt_boundary_data_st {
+    const char *alg;
+    size_t msglen;
+    size_t customlen;
+    const unsigned char *expected;
+    size_t expected_len;
+} KT_BOUNDARY_DATA;
+
+static const unsigned char kt128_8190[] = {
+    0x7a, 0xc8, 0x1b, 0x54, 0x96, 0x13, 0x3d, 0x56,
+    0x4d, 0x35, 0xc6, 0xb5, 0xe6, 0x6e, 0x2f, 0x95,
+    0xea, 0x2a, 0xe8, 0xd7, 0x75, 0xf6, 0x04, 0x20,
+    0xab, 0xb0, 0xa1, 0x50, 0x24, 0xd3, 0xd4, 0xf8
+};
+
+static const unsigned char kt128_8191[] = {
+    0x1b, 0x57, 0x76, 0x36, 0xf7, 0x23, 0x64, 0x3e,
+    0x99, 0x0c, 0xc7, 0xd6, 0xa6, 0x59, 0x83, 0x74,
+    0x36, 0xfd, 0x6a, 0x10, 0x36, 0x26, 0x60, 0x0e,
+    0xb8, 0x30, 0x1c, 0xd1, 0xdb, 0xe5, 0x53, 0xd6
+};
+
+static const unsigned char kt128_8192[] = {
+    0x48, 0xf2, 0x56, 0xf6, 0x77, 0x2f, 0x9e, 0xdf,
+    0xb6, 0xa8, 0xb6, 0x61, 0xec, 0x92, 0xdc, 0x93,
+    0xb9, 0x5e, 0xbd, 0x05, 0xa0, 0x8a, 0x17, 0xb3,
+    0x9a, 0xe3, 0x49, 0x08, 0x70, 0xc9, 0x26, 0xc3
+};
+
+static const unsigned char kt128_8191_c2[] = {
+    0x04, 0x51, 0x48, 0xe4, 0x7b, 0x68, 0xc8, 0xb5,
+    0x8d, 0x37, 0xc2, 0xdc, 0x37, 0xf4, 0x35, 0x2d,
+    0x6e, 0x2d, 0x1b, 0xce, 0xb6, 0xca, 0x63, 0x02,
+    0x37, 0x2d, 0xc2, 0x7f, 0xd3, 0x77, 0x9f, 0x04
+};
+
+static const unsigned char kt128_16383[] = {
+    0xe3, 0xde, 0xd5, 0x21, 0x18, 0xea, 0x64, 0xea,
+    0xf0, 0x4c, 0x75, 0x31, 0xc6, 0xcc, 0xb9, 0x5e,
+    0x32, 0x92, 0x4b, 0x7c, 0x2b, 0x87, 0xb2, 0xce,
+    0x68, 0xff, 0x2f, 0x2e, 0xe4, 0x6e, 0x84, 0xef
+};
+
+static const unsigned char kt128_16384[] = {
+    0x82, 0x77, 0x8f, 0x7f, 0x72, 0x34, 0xc8, 0x33,
+    0x52, 0xe7, 0x68, 0x37, 0xb7, 0x21, 0xfb, 0xdb,
+    0xb5, 0x27, 0x0b, 0x88, 0x01, 0x0d, 0x84, 0xfa,
+    0x5a, 0xb0, 0xb6, 0x1e, 0xc8, 0xce, 0x09, 0x56
+};
+
+#if 0
+/*
+ * This RFC 9861 tree-boundary vector uses an 8189-byte customization string,
+ * which is longer than OpenSSL's provider limit of 512 bytes.
+ */
+static const unsigned char kt128_8192_c8189[] = {
+    0x3e, 0xd1, 0x2f, 0x70, 0xfb, 0x05, 0xdd, 0xb5,
+    0x86, 0x89, 0x51, 0x0a, 0xb3, 0xe4, 0xd2, 0x3c,
+    0x6c, 0x60, 0x33, 0x84, 0x9a, 0xa0, 0x1e, 0x1d,
+    0x8c, 0x22, 0x0a, 0x29, 0x7f, 0xed, 0xcd, 0x0b
+};
+#endif
+
+static const unsigned char kt256_8192[] = {
+    0xc6, 0xee, 0x8e, 0x2a, 0xd3, 0x20, 0x0c, 0x01,
+    0x8a, 0xc8, 0x7a, 0xaa, 0x03, 0x1c, 0xda, 0xc2,
+    0x21, 0x21, 0xb4, 0x12, 0xd0, 0x7d, 0xc6, 0xe0,
+    0xdc, 0xcb, 0xb5, 0x34, 0x23, 0x74, 0x7e, 0x9a,
+    0x1c, 0x18, 0x83, 0x4d, 0x99, 0xdf, 0x59, 0x6c,
+    0xf0, 0xcf, 0x4b, 0x8d, 0xfa, 0xfb, 0x7b, 0xf0,
+    0x2d, 0x13, 0x9d, 0x0c, 0x90, 0x35, 0x72, 0x5a,
+    0xdc, 0x1a, 0x01, 0xb7, 0x23, 0x0a, 0x41, 0xfa
+};
+
+static const KT_BOUNDARY_DATA kt_boundary_tests[] = {
+    /* |S| = 8191, 8192, and 8193, respectively. */
+    { "KT128", 8190, 0, kt128_8190, sizeof(kt128_8190) },
+    { "KT128", 8191, 0, kt128_8191, sizeof(kt128_8191) },
+    { "KT128", 8192, 0, kt128_8192, sizeof(kt128_8192) },
+    /* Byte 8193 of S is the second customization byte. */
+    { "KT128", 8191, 2, kt128_8191_c2, sizeof(kt128_8191_c2) },
+    /* Exercise an exactly full leaf and a following partial leaf. */
+    { "KT128", 16383, 0, kt128_16383, sizeof(kt128_16383) },
+    { "KT128", 16384, 0, kt128_16384, sizeof(kt128_16384) },
+#if 0
+    /*
+     * This RFC 9861 tree-boundary vector uses an 8189-byte customization
+     * string, which is longer than OpenSSL's provider limit of 512 bytes.
+     */
+    { "KT128", 8192, 8189, kt128_8192_c8189,
+        sizeof(kt128_8192_c8189) },
+#endif
+    { "KT256", 8192, 0, kt256_8192, sizeof(kt256_8192) },
+};
+
+static int kt_boundary_test(int tstid)
+{
+    const KT_BOUNDARY_DATA *td = kt_boundary_tests + tstid;
+    unsigned char *msg = NULL, *custom = NULL;
+    unsigned char *one_shot = NULL, *chunked = NULL;
+    OSSL_PARAM params[2], *p = params;
+    int ret = 0;
+
+    if (!TEST_ptr(msg = OPENSSL_malloc(td->msglen))
+        || !TEST_ptr(one_shot = OPENSSL_malloc(td->expected_len))
+        || !TEST_ptr(chunked = OPENSSL_malloc(td->expected_len)))
+        goto err;
+    fill_ptn(msg, td->msglen);
+    if (td->customlen > 0) {
+        if (!TEST_ptr(custom = OPENSSL_malloc(td->customlen)))
+            goto err;
+        fill_ptn(custom, td->customlen);
+        *p++ = OSSL_PARAM_construct_octet_string(
+            OSSL_DIGEST_PARAM_CUSTOMIZATION, custom, td->customlen);
+    }
+    *p = OSSL_PARAM_construct_end();
+
+    if (!digest_xof_with_params(td->alg, msg, td->msglen, params, one_shot,
+            td->expected_len)
+        || !digest_xof_chunked_with_params(td->alg, msg, td->msglen, params,
+            chunked, td->expected_len)
+        || !TEST_mem_eq(one_shot, td->expected_len, td->expected,
+            td->expected_len)
+        || !TEST_mem_eq(chunked, td->expected_len, td->expected,
+            td->expected_len)
+        || !TEST_mem_eq(one_shot, td->expected_len, chunked,
+            td->expected_len))
+        goto err;
+    ret = 1;
+err:
+    OPENSSL_free(chunked);
+    OPENSSL_free(one_shot);
+    OPENSSL_free(custom);
+    OPENSSL_free(msg);
+    return ret;
+}
+#endif
+
 static const struct {
     size_t len;
     int should_pass;
@@ -674,6 +1755,28 @@ static int xof_fail_test(void)

 int setup_tests(void)
 {
+    const char *fips_config_file;
+
+    if (!test_skip_common_options()) {
+        TEST_error("Error parsing test options\n");
+        return 0;
+    }
+
+    if (test_get_argument_count() > 0) {
+        if (test_get_argument_count() != 2
+            || strcmp(test_get_argument(0), "fips") != 0
+            || !TEST_ptr(fips_config_file = test_get_argument(1)))
+            return 0;
+        if (!test_get_libctx(&fips_libctx, &nullprov, fips_config_file,
+                &fipsprov, "fips")) {
+            cleanup_tests();
+            return 0;
+        }
+        if (fips_provider_version_ge(fips_libctx, 4, 2, 0))
+            ADD_TEST(cshake_custom_fips_test);
+        return 1;
+    }
+
     ADD_ALL_TESTS(xof_kat_test, OSSL_NELEM(xof_test_data));
     ADD_ALL_TESTS(xof_kat_digestfinal_test, OSSL_NELEM(xof_test_data));
     ADD_ALL_TESTS(xof_kat_digestfinal_xoflen_test, OSSL_NELEM(xof_test_data));
@@ -683,6 +1786,39 @@ int setup_tests(void)
     ADD_ALL_TESTS(xof_squeeze_large_test, OSSL_NELEM(stride_test_data));
     ADD_ALL_TESTS(xof_squeeze_dup_test, OSSL_NELEM(dupoffset_test_data));
     ADD_ALL_TESTS(xof_customization_boundary_test, OSSL_NELEM(customization_boundary_test_data));
+#ifndef OPENSSL_NO_TURBOSHAKE
+    ADD_ALL_TESTS(turboshake_segmented_squeeze_test,
+        OSSL_NELEM(turboshake_squeeze_tests));
+#endif
+#if !defined(OPENSSL_NO_TURBOSHAKE) || !defined(OPENSSL_NO_KT)
+    ADD_ALL_TESTS(turboshake_kt_vector_test, OSSL_NELEM(turboshake_kt_vectors));
+    ADD_ALL_TESTS(turboshake_kt_chunked_absorb_and_size_test,
+        OSSL_NELEM(turboshake_kt_tests));
+    ADD_ALL_TESTS(turboshake_kt_copyctx_test, OSSL_NELEM(turboshake_kt_tests));
+    ADD_ALL_TESTS(turboshake_kt_xoflen_alias_conflict_test,
+        OSSL_NELEM(turboshake_kt_tests));
+#endif
+#ifndef OPENSSL_NO_TURBOSHAKE
+    ADD_TEST(turboshake_repeated_param_test);
+    ADD_TEST(turboshake_domain_test);
+#endif
+#ifndef OPENSSL_NO_KT
+    ADD_TEST(kt_repeated_param_test);
+    ADD_TEST(kt_custom_octet_test);
+    ADD_TEST(kt_custom_null_octet_test);
+    ADD_TEST(kt_custom_limit_test);
+    ADD_ALL_TESTS(kt_boundary_test, OSSL_NELEM(kt_boundary_tests));
+#endif
+    ADD_TEST(cshake_custom_test);
     ADD_TEST(xof_fail_test);
     return 1;
 }
+
+void cleanup_tests(void)
+{
+    OSSL_PROVIDER_unload(fipsprov);
+    OSSL_PROVIDER_unload(nullprov);
+    OSSL_LIB_CTX_free(fips_libctx);
+}
+
+OPT_TEST_DECLARE_USAGE("[fips configfile]")
diff --git a/test/recipes/30-test_evp.t b/test/recipes/30-test_evp.t
index 543c28c88a..127818a365 100644
--- a/test/recipes/30-test_evp.t
+++ b/test/recipes/30-test_evp.t
@@ -180,8 +180,10 @@ my @defltfiles = qw(
                      evpmd_blake.txt
                      evpmd_md.txt
                      evpmd_mdc2.txt
+                     evpmd_kt.txt
                      evpmd_ripemd.txt
                      evpmd_sm3.txt
+                     evpmd_turboshake.txt
                      evpmd_whirlpool.txt
                      evppbe_scrypt.txt
                      evppbe_pkcs12.txt
diff --git a/test/recipes/30-test_evp_data/evpmd_kt.txt b/test/recipes/30-test_evp_data/evpmd_kt.txt
new file mode 100644
index 0000000000..a440c0dfb5
--- /dev/null
+++ b/test/recipes/30-test_evp_data/evpmd_kt.txt
@@ -0,0 +1,25 @@
+#
+# Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+#
+# Licensed under the Apache License 2.0 (the "License").  You may not use
+# this file except in compliance with the License.  You can obtain a copy
+# in the file LICENSE in the source distribution or at
+# https://www.openssl.org/source/license.html
+
+Title = RFC 9861 KT tests
+
+Digest = KT128
+Input = ""
+Output = 1AC2D450FC3B4205D19DA7BFCA1B37513C0803577AC7167F06FE2CE1F0EF39E5
+
+Digest = KT128
+Input = ""
+Output = 1AC2D450FC3B4205D19DA7BFCA1B37513C0803577AC7167F06FE2CE1F0EF39E54269C056B8C82E48276038B6D292966CC07A3D4645272E31FF38508139EB0A71
+
+Digest = KT256
+Input = ""
+Output = B23D2E9CEA9F4904E02BEC06817FC10CE38CE8E93EF4C89E6537076AF8646404E3E8B68107B8833A5D30490AA33482353FD4ADC7148ECB782855003AAEBDE4A9
+
+Digest = KT256
+Input = ""
+Output = B23D2E9CEA9F4904E02BEC06817FC10CE38CE8E93EF4C89E6537076AF8646404E3E8B68107B8833A5D30490AA33482353FD4ADC7148ECB782855003AAEBDE4A9B0925319D8EA1E121A609821EC19EFEA89E6D08DAEE1662B69C840289F188BA860F55760B61F82114C030C97E5178449608CCD2CD2D919FC7829FF69931AC4D0
diff --git a/test/recipes/30-test_evp_data/evpmd_turboshake.txt b/test/recipes/30-test_evp_data/evpmd_turboshake.txt
new file mode 100644
index 0000000000..ce31755704
--- /dev/null
+++ b/test/recipes/30-test_evp_data/evpmd_turboshake.txt
@@ -0,0 +1,81 @@
+#
+# Copyright 2026 The OpenSSL Project Authors. All Rights Reserved.
+#
+# Licensed under the Apache License 2.0 (the "License").  You may not use
+# this file except in compliance with the License.  You can obtain a copy
+# in the file LICENSE in the source distribution or at
+# https://www.openssl.org/source/license.html
+
+Title = RFC 9861 TurboSHAKE tests
+
+Digest = TURBOSHAKE128
+Input = ""
+Output = 1E415F1C5983AFF2169217277D17BB538CD945A397DDEC541F1CE41AF2C1B74C
+
+Digest = TURBOSHAKE128
+Input = ""
+Output = 1E415F1C5983AFF2169217277D17BB538CD945A397DDEC541F1CE41AF2C1B74C3E8CCAE2A4DAE56C84A04C2385C03C15E8193BDF58737363321691C05462C8DF
+
+Digest = TURBOSHAKE128
+Input = FFFFFF
+Output = BF323F940494E88EE1C540FE660BE8A0C93F43D15EC006998462FA994EED5DAB
+Ctrl = domain-separator:1
+
+Digest = TURBOSHAKE128
+Input = FF
+Output = 8EC9C66465ED0D4A6C35D13506718D687A25CB05C74CCA1E42501ABD83874A67
+Ctrl = domain-separator:6
+
+Digest = TURBOSHAKE128
+Input = FFFFFF
+Output = B658576001CAD9B1E5F399A9F77723BBA05458042D68206F7252682DBA3663ED
+Ctrl = domain-separator:7
+
+Digest = TURBOSHAKE128
+Input = FFFFFFFFFFFFFF
+Output = 8DEEAA1AEC47CCEE569F659C21DFA8E112DB3CEE37B18178B2ACD805B799CC37
+Ctrl = domain-separator:11
+
+Digest = TURBOSHAKE128
+Input = FF
+Output = 553122E2135E363C3292BED2C6421FA232BAB03DAA07C7D6636603286506325B
+Ctrl = domain-separator:48
+
+Digest = TURBOSHAKE128
+Input = FFFFFF
+Output = 16274CC656D44CEFD422395D0F9053BDA6D28E122ABA15C765E5AD0E6EAF26F9
+Ctrl = domain-separator:127
+
+Digest = TURBOSHAKE256
+Input = ""
+Output = 367A329DAFEA871C7802EC67F905AE13C57695DC2C6663C61035F59A18F8E7DB11EDC0E12E91EA60EB6B32DF06DD7F002FBAFABB6E13EC1CC20D995547600DB0
+
+Digest = TURBOSHAKE256
+Input = FFFFFF
+Output = D21C6FBBF587FA2282F29AEA620175FB0257413AF78A0B1B2A87419CE031D933AE7A4D383327A8A17641A34F8A1D1003AD7DA6B72DBA84BB62FEF28F62F12424
+Ctrl = domain-separator:1
+
+Digest = TURBOSHAKE256
+Input = FF
+Output = 738D7B4E37D18B7F22AD1B5313E357E3DD7D07056A26A303C433FA3533455280F4F5A7D4F700EFB437FE6D281405E07BE32A0A972E22E63ADC1B090DAEFE004B
+Ctrl = domain-separator:6
+
+Digest = TURBOSHAKE256
+Input = FFFFFF
+Output = 18B3B5B7061C2E67C1753A00E6AD7ED7BA1C906CF93EFB7092EAF27FBEEBB755AE6E292493C110E48D260028492B8E09B5500612B8F2578985DED5357D00EC67
+Ctrl = domain-separator:7
+
+Digest = TURBOSHAKE256
+Input = FFFFFFFFFFFFFF
+Output = BB36764951EC97E9D85F7EE9A67A7718FC005CF42556BE79CE12C0BDE50E5736D6632B0D0DFB202D1BBB8FFE3DD74CB00834FA756CB03471BAB13A1E2C16B3C0
+Ctrl = domain-separator:11
+
+Digest = TURBOSHAKE256
+Input = FF
+Output = F3FE12873D34BCBB2E608779D6B70E7F86BEC7E90BF113CBD4FDD0C4E2F4625E148DD7EE1A52776CF77F240514D9CCFC3B5DDAB8EE255E39EE389072962C111A
+Ctrl = domain-separator:48
+
+Digest = TURBOSHAKE256
+Input = FFFFFF
+Output = ABE569C1F77EC340F02705E7D37C9AB7E155516E4A6A150021D70B6FAC0BB40C069F9A9828A0D575CD99F9BAE435AB1ACF7ED9110BA97CE0388D074BAC768776
+Ctrl = domain-separator:127
diff --git a/test/recipes/30-test_evp_xof.t b/test/recipes/30-test_evp_xof.t
index c3dd6062de..90621fc733 100644
--- a/test/recipes/30-test_evp_xof.t
+++ b/test/recipes/30-test_evp_xof.t
@@ -6,7 +6,22 @@
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html

+use strict;
+use warnings;

-use OpenSSL::Test::Simple;
+use OpenSSL::Test qw(:DEFAULT srctop_file);
+use OpenSSL::Test::Utils;

-simple_test("test_evp_xof", "evp_xof_test");
+BEGIN {
+    setup("test_evp_xof");
+}
+
+my $no_fips = disabled('fips') || ($ENV{NO_FIPS} // 0);
+
+plan tests => $no_fips ? 1 : 2;
+
+ok(run(test(["evp_xof_test"])), "running evp_xof_test");
+
+ok(run(test(["evp_xof_test", "fips", srctop_file("test", "fips-and-base.cnf")])),
+   "running evp_xof_test with the FIPS provider")
+    unless $no_fips;
diff --git a/util/perl/OpenSSL/paramnames.pm b/util/perl/OpenSSL/paramnames.pm
index 93ed49e448..5ea5a6244d 100644
--- a/util/perl/OpenSSL/paramnames.pm
+++ b/util/perl/OpenSSL/paramnames.pm
@@ -176,7 +176,8 @@ my %params = (
     'OSSL_DIGEST_PARAM_XOF' =>          "xof",          # int, 0 or 1
     'OSSL_DIGEST_PARAM_ALGID_ABSENT' => "algid-absent", # int, 0 or 1
     'OSSL_DIGEST_PARAM_FUNCTION_NAME' =>    "function-name", # utf8 string
-    'OSSL_DIGEST_PARAM_CUSTOMIZATION' =>    "customization", # utf8 string
+    'OSSL_DIGEST_PARAM_CUSTOMIZATION' =>    "customization", # utf8 string or octet string
+    'OSSL_DIGEST_PARAM_DOMAIN_SEPARATOR' => "domain-separator", # uint
     'OSSL_DIGEST_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
     'OSSL_DIGEST_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',# utf8 string