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