mirror of
https://github.com/open-quantum-safe/liboqs.git
synced 2025-07-03 00:01:44 -04:00
Compare commits
11 Commits
ba5a3d658e
...
1e6e985a87
| Author | SHA1 | Date | |
|---|---|---|---|
|
1e6e985a87 | ||
|
4be4ed9d63 | ||
|
|
5b6b1ca95e | ||
|
|
549bb753ec | ||
|
|
0d187d217c | ||
|
|
4a7e91b2d6 | ||
|
|
2989a0ced4 | ||
|
|
3c8ce0fec8 | ||
|
|
00640511a3 | ||
|
|
2df1f71917 | ||
|
|
146992cbe1 |
File diff suppressed because one or more lines are too long
1
.gitignore
vendored
1
.gitignore
vendored
@ -39,4 +39,3 @@ compile_commands.json
|
||||
|
||||
# Generated by Nix flake
|
||||
result/
|
||||
|
||||
|
||||
@ -271,6 +271,9 @@ if(OQS_ENABLE_SIG_SNOVA)
|
||||
set(PUBLIC_HEADERS ${PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/src/sig/snova/sig_snova.h)
|
||||
endif()
|
||||
##### OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_HEADERS_END
|
||||
if(OQS_ENABLE_SIG_SLH_DSA)
|
||||
set(PUBLIC_HEADERS ${PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/src/sig/slh_dsa/sig_slh_dsa.h)
|
||||
endif()
|
||||
if(OQS_ENABLE_SIG_STFL_XMSS)
|
||||
set(PUBLIC_HEADERS ${PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/src/sig_stfl/xmss/sig_stfl_xmss.h)
|
||||
endif()
|
||||
|
||||
171
docs/algorithms/sig/slh_dsa.md
Normal file
171
docs/algorithms/sig/slh_dsa.md
Normal file
@ -0,0 +1,171 @@
|
||||
!!!!!!! Variants are listed here to safisfy code conventions requirements
|
||||
Proper documentation is still required !!!!!!!
|
||||
|
||||
SLH_DSA_PURE_SHA2_128S
|
||||
SLH_DSA_PURE_SHA2_128F
|
||||
SLH_DSA_PURE_SHA2_192S
|
||||
SLH_DSA_PURE_SHA2_192F
|
||||
SLH_DSA_PURE_SHA2_256S
|
||||
SLH_DSA_PURE_SHA2_256F
|
||||
SLH_DSA_PURE_SHAKE_128S
|
||||
SLH_DSA_PURE_SHAKE_128F
|
||||
SLH_DSA_PURE_SHAKE_192S
|
||||
SLH_DSA_PURE_SHAKE_192F
|
||||
SLH_DSA_PURE_SHAKE_256S
|
||||
SLH_DSA_PURE_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_224_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_256_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_384_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_512_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA3_224_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA3_256_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA3_384_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHA3_512_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHAKE_128_PREHASH_SHAKE_256F
|
||||
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_128S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_128F
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_192S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_192F
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_256S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHA2_256F
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_128S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_128F
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_192S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_192F
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_256S
|
||||
SLH_DSA_SHAKE_256_PREHASH_SHAKE_256F
|
||||
286
scripts/copy_from_upstream/copy_from_slh_dsa_c.py
Normal file
286
scripts/copy_from_upstream/copy_from_slh_dsa_c.py
Normal file
@ -0,0 +1,286 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
|
||||
import os
|
||||
import yaml
|
||||
import tarfile
|
||||
import requests
|
||||
import shutil
|
||||
import jinja2
|
||||
import glob
|
||||
import itertools
|
||||
|
||||
#get contents of a file
|
||||
def file_get_contents(filename, encoding=None):
|
||||
with open(filename, mode='r', encoding=encoding) as fh:
|
||||
return fh.read()
|
||||
|
||||
#copy tarball of the specified commit
|
||||
def copy_from_commit():
|
||||
tar_name = 'slh_dsa_c.tar.gz'
|
||||
tar_path = os.path.join(slh_dir, tar_name)
|
||||
|
||||
#clean up code
|
||||
shutil.rmtree(os.path.join(slh_dsa_c_dir))
|
||||
|
||||
url = os.path.join('https://github.com/pq-code-package/slhdsa-c/archive/', commit_hash, ".tar.gz")
|
||||
|
||||
response = requests.get(url)
|
||||
|
||||
if response.status_code == 200:
|
||||
os.makedirs(slh_dir, exist_ok=True)
|
||||
|
||||
with open(tar_path, 'wb') as file:
|
||||
file.write(response.content)
|
||||
|
||||
tar_file = tarfile.open(tar_path)
|
||||
tar_file.extractall(slh_dir)
|
||||
tar_file.close()
|
||||
os.remove(tar_path)
|
||||
|
||||
for entry in os.listdir(slh_dir):
|
||||
if entry[:6] == 'slhdsa':
|
||||
full_path = os.path.join(slh_dir, entry)
|
||||
if os.path.isdir(full_path):
|
||||
os.rename(full_path, slh_dsa_temp_dir)
|
||||
|
||||
#load meta file
|
||||
meta = file_get_contents(meta_file, encoding='utf-8')
|
||||
meta = yaml.safe_load(meta)
|
||||
|
||||
#copy sources from temp
|
||||
os.makedirs(slh_dsa_c_dir, exist_ok=True)
|
||||
sources = meta['sources']
|
||||
|
||||
for root, dirs, files in os.walk(slh_dsa_temp_dir):
|
||||
for file in files:
|
||||
full_path = os.path.join(root, file)
|
||||
rel_path = os.path.relpath(full_path, slh_dsa_temp_dir)
|
||||
if rel_path in sources:
|
||||
os.makedirs(os.path.dirname(os.path.join(slh_dsa_c_dir,rel_path)), exist_ok=True)
|
||||
shutil.copy(os.path.join(slh_dsa_temp_dir,rel_path), os.path.join(slh_dsa_c_dir,rel_path))
|
||||
|
||||
shutil.rmtree(slh_dsa_temp_dir)
|
||||
|
||||
print('Copied from slh dsa commit succesfully')
|
||||
else:
|
||||
print('Failed to copy from slh dsa commit')
|
||||
|
||||
# Will retrieve start or end indices for sections
|
||||
def section_bound(identifier, delimiter, text, side):
|
||||
searchString = delimiter + ' OQS_COPY_FROM_SLH_DSA_FRAGMENT_' + identifier + '_' + side
|
||||
res = text.find(searchString)
|
||||
if side == 'START':
|
||||
res += len(searchString)
|
||||
return res
|
||||
|
||||
#replace a single fragment
|
||||
def fragment_replacer(template_file, destination_file, identifier, variants, destination_delimiter):
|
||||
#get section at identifier in template
|
||||
template = file_get_contents(template_file)
|
||||
section = template[section_bound(identifier,'#####',template,'START'):section_bound(identifier,'#####',template,'END')]
|
||||
|
||||
#get preamble/postamble in destination file
|
||||
destination = file_get_contents(destination_file)
|
||||
preamble = destination[:section_bound(identifier,destination_delimiter,destination,'START')]
|
||||
postamble = destination[section_bound(identifier,destination_delimiter,destination,'END'):]
|
||||
|
||||
#replace destination section with rendered template
|
||||
contents = preamble + jinja2.Template(section).render(variants) + postamble
|
||||
with open(destination_file, "w") as f:
|
||||
f.write(contents)
|
||||
|
||||
#replace all fragment in destination file
|
||||
def file_replacer(template_file, destination_file, variants, destination_delimiter):
|
||||
#get fragment list in template file
|
||||
template = file_get_contents(template_file)
|
||||
list_string = template[section_bound('IDENTIFIER_LIST','#####',template,'START'):section_bound('IDENTIFIER_LIST','#####',template,'END')]
|
||||
id_list = list_string.split()
|
||||
for id in id_list:
|
||||
fragment_replacer(template_file,destination_file,id,variants, destination_delimiter)
|
||||
|
||||
#generate slh_dsa specific files
|
||||
def internal_code_gen():
|
||||
#clean up code
|
||||
shutil.rmtree(slh_wrappers_dir)
|
||||
|
||||
#Start Header File and Setup
|
||||
header_template = file_get_contents(jinja_header_file)
|
||||
|
||||
header_section = header_template[section_bound('0','#####', header_template,'START'):section_bound('0','#####',header_template,'END')]
|
||||
header_contents = jinja2.Template(header_section).render()
|
||||
|
||||
src_template = file_get_contents(jinja_src_file)
|
||||
header_section = header_template[section_bound('BODY','#####',header_template,'START'):section_bound('BODY','#####',header_template,'END')]
|
||||
|
||||
algDetails = meta['algDetails']
|
||||
impl['algVersion'] = algDetails['algVersion']
|
||||
impl['claimedNISTLevel'] = algDetails['claimedNISTLevel']
|
||||
impl['eufCMA'] = algDetails['eufCMA']
|
||||
impl['sufCMA'] = algDetails['sufCMA']
|
||||
|
||||
# Create Src Files for Pure variants
|
||||
for paramSet in meta['paramSets']:
|
||||
impl['paramSet'] = paramSet['name']
|
||||
impl['pkSize'] = paramSet['pkSize']
|
||||
impl['skSize'] = paramSet['skSize']
|
||||
impl['sigSize'] = paramSet['sigSize']
|
||||
|
||||
for hashAlg in meta['hashAlgs']:
|
||||
impl['hashAlg'] = hashAlg['name']
|
||||
|
||||
src_contents = jinja2.Template(src_template).render(impl)
|
||||
|
||||
src_file = 'slh_dsa_pure_' + impl['hashAlg'] + '_' + impl['paramSet'] + '.c'
|
||||
src_path = os.path.join(slh_wrappers_dir, 'pure', src_file)
|
||||
os.makedirs(os.path.dirname(src_path),exist_ok=True)
|
||||
|
||||
with open(src_path, "w") as f:
|
||||
f.write(src_contents)
|
||||
|
||||
header_contents += jinja2.Template(header_section).render(impl)
|
||||
|
||||
# Create Src Files for Prehash variants
|
||||
impl['pure'] = False
|
||||
|
||||
for paramSet in meta['paramSets']:
|
||||
impl['paramSet'] = paramSet['name']
|
||||
impl['pkSize'] = paramSet['pkSize']
|
||||
impl['skSize'] = paramSet['skSize']
|
||||
impl['sigSize'] = paramSet['sigSize']
|
||||
|
||||
for hashAlg in meta['hashAlgs']:
|
||||
impl['hashAlg'] = hashAlg['name']
|
||||
|
||||
for prehashHashAlg in meta['prehashHashAlgs']:
|
||||
impl['prehashHashAlg'] = prehashHashAlg['name']
|
||||
|
||||
src_contents = jinja2.Template(src_template).render(impl)
|
||||
|
||||
src_file = 'slh_dsa_' + impl['prehashHashAlg'] + '_prehash_' + impl['hashAlg'] + '_' + impl['paramSet'] + '.c'
|
||||
src_path = os.path.join(slh_wrappers_dir, 'prehash_' + prehashHashAlg['name'], src_file)
|
||||
os.makedirs(os.path.dirname(src_path),exist_ok=True)
|
||||
|
||||
with open(src_path, "w") as f:
|
||||
f.write(src_contents)
|
||||
|
||||
header_contents += jinja2.Template(header_section).render(impl)
|
||||
|
||||
#finish header file
|
||||
header_section = header_template[section_bound('2','#####',header_template,'START'):section_bound('2','#####',header_template,'END')]
|
||||
header_contents += jinja2.Template(header_section).render()
|
||||
header_file = "sig_slh_dsa.h"
|
||||
header_path = os.path.join(slh_dir, header_file)
|
||||
with open(header_path, "w") as f:
|
||||
f.write(header_contents)
|
||||
|
||||
def internal_cmake_gen():
|
||||
sources = [
|
||||
os.path.relpath(file, start=slh_dir)
|
||||
for file in glob.glob(os.path.join(slh_dir, '**', '*.c'), recursive=True)
|
||||
if 'slh_dsa_c/test/' not in os.path.relpath(file, start=slh_dir)
|
||||
]
|
||||
prehashHashAlgs = [prehashHashAlg['name'] for prehashHashAlg in meta['prehashHashAlgs']]
|
||||
|
||||
cmake_template = file_get_contents(jinja_cmake_file)
|
||||
cmake_contents = jinja2.Template(cmake_template).render({"sources": sources,
|
||||
"prehashHashAlgs": prehashHashAlgs})
|
||||
cmake_file = "CMakeLists.txt"
|
||||
cmake_path = os.path.join(slh_dir, cmake_file)
|
||||
with open(cmake_path, "w") as f:
|
||||
f.write(cmake_contents)
|
||||
|
||||
#create list of all slh_dsa variants
|
||||
def list_variants():
|
||||
variants = []
|
||||
#add pure variants
|
||||
for hashAlg, paramSet in itertools.product(meta['hashAlgs'], meta['paramSets']):
|
||||
variants.append('pure_' + hashAlg['name'] + '_' + paramSet['name'])
|
||||
#add prehash variants
|
||||
for prehashHashAlg, hashAlg, paramSet in itertools.product(meta['prehashHashAlgs'], meta['hashAlgs'], meta['paramSets']):
|
||||
variants.append(prehashHashAlg['name'] + '_prehash_' + hashAlg['name'] + '_' + paramSet['name'])
|
||||
return variants
|
||||
|
||||
def main():
|
||||
os.chdir(os.path.join(os.environ['LIBOQS_DIR']))
|
||||
|
||||
#initialize globals
|
||||
global commit_hash, slh_dir, slh_dsa_c_dir, slh_dsa_temp_dir, slh_wrappers_dir, template_dir, meta_file, \
|
||||
jinja_header_file, jinja_src_file, jinja_cmake_file, meta, impl, variants, jinja_sig_c_file, \
|
||||
jinja_sig_h_file, jinja_alg_support_file, jinja_oqsconfig_file, sig_c_path, sig_h_path, \
|
||||
alg_support_path, oqsconfig_path
|
||||
|
||||
# This commit hash will need to be updated
|
||||
commit_hash = "16cdd85ee74095592d975ff30afa682075a5a00b"
|
||||
|
||||
# internal paths
|
||||
slh_dir = os.path.join(os.environ['LIBOQS_DIR'], 'src/sig/slh_dsa')
|
||||
slh_dsa_c_dir = os.path.join(slh_dir, 'slh_dsa_c')
|
||||
slh_dsa_temp_dir = os.path.join(slh_dir, 'slh_dsa_temp')
|
||||
slh_wrappers_dir = os.path.join(slh_dir, 'wrappers')
|
||||
template_dir = os.path.join(slh_dir, 'templates')
|
||||
|
||||
#ensure these paths exist
|
||||
os.makedirs(slh_dir,exist_ok=True)
|
||||
os.makedirs(slh_dsa_c_dir,exist_ok=True)
|
||||
os.makedirs(slh_wrappers_dir,exist_ok=True)
|
||||
os.makedirs(template_dir,exist_ok=True)
|
||||
|
||||
# internal files
|
||||
meta_file = os.path.join(slh_dsa_temp_dir, 'integration/liboqs/META.yml')
|
||||
jinja_header_file = os.path.join(template_dir, 'slh_dsa_header_template.jinja')
|
||||
jinja_src_file = os.path.join(template_dir, 'slh_dsa_src_template.jinja')
|
||||
jinja_cmake_file = os.path.join(template_dir, 'slh_dsa_cmake_template.jinja')
|
||||
|
||||
#copy source code from upstream
|
||||
copy_from_commit()
|
||||
|
||||
#load meta file globally
|
||||
meta_file = os.path.join(slh_dsa_c_dir, 'integration/liboqs/META.yml')
|
||||
meta = file_get_contents(meta_file, encoding='utf-8')
|
||||
meta = yaml.safe_load(meta)
|
||||
|
||||
#Create implementation dictionary
|
||||
impl = {
|
||||
"pure": True,
|
||||
"paramSet": "",
|
||||
"hashAlg": "",
|
||||
"prehashHashAlg": "",
|
||||
"pkSize": "",
|
||||
"skSize": "",
|
||||
"sigSize": "",
|
||||
"algVersion": "",
|
||||
"claimedNISTLevel": "",
|
||||
"eufCMA": "",
|
||||
"sufCMA": ""
|
||||
}
|
||||
|
||||
#Replace contents of other files using fragments
|
||||
#generate variant list
|
||||
variants = list_variants()
|
||||
|
||||
#enumerate template file paths
|
||||
jinja_sig_c_file = os.path.join(template_dir,'slh_dsa_sig_c_template.jinja')
|
||||
jinja_sig_h_file = os.path.join(template_dir,'slh_dsa_sig_h_template.jinja')
|
||||
jinja_alg_support_file = os.path.join(template_dir,'slh_dsa_alg_support_template.jinja')
|
||||
jinja_oqsconfig_file = os.path.join(template_dir,'slh_dsa_oqsconfig_template.jinja')
|
||||
|
||||
#enumerate destination file paths
|
||||
sig_c_path = os.path.join(os.environ['LIBOQS_DIR'],'src','sig','sig.c')
|
||||
sig_h_path = os.path.join(os.environ['LIBOQS_DIR'],'src','sig','sig.h')
|
||||
alg_support_path = os.path.join(os.environ['LIBOQS_DIR'],'.CMake','alg_support.cmake')
|
||||
oqsconfig_path = os.path.join(os.environ['LIBOQS_DIR'],'src','oqsconfig.h.cmake')
|
||||
|
||||
#generate internal c and h files
|
||||
internal_code_gen()
|
||||
|
||||
#generate internal cmake file
|
||||
internal_cmake_gen()
|
||||
|
||||
#replace file contents
|
||||
file_replacer(jinja_sig_c_file, sig_c_path, {'variants': variants},'/////')
|
||||
file_replacer(jinja_sig_h_file, sig_h_path, {'variants': variants},'/////')
|
||||
file_replacer(jinja_alg_support_file, alg_support_path, {'variants': variants},'#####')
|
||||
file_replacer(jinja_oqsconfig_file, oqsconfig_path, {'variants': variants},'/////')
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -15,6 +15,7 @@ import sys
|
||||
import json
|
||||
import platform
|
||||
import update_upstream_alg_docs
|
||||
import copy_from_slh_dsa_c
|
||||
|
||||
# kats of all algs
|
||||
kats = {}
|
||||
@ -836,6 +837,7 @@ non_upstream_kems = count_non_upstream_kems(['bike', 'frodokem', 'ntruprime'])
|
||||
|
||||
if args.operation == "copy":
|
||||
copy_from_upstream()
|
||||
copy_from_slh_dsa_c.main()
|
||||
elif args.operation == "libjade":
|
||||
copy_from_libjade()
|
||||
elif args.operation == "verify":
|
||||
|
||||
@ -10,3 +10,4 @@ tabulate==0.8.10
|
||||
typing-extensions==3.7.4.3
|
||||
wget==3.2
|
||||
zipp==3.19.1
|
||||
requests==2.32.4
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#
|
||||
# This file is autogenerated by pip-compile with Python 3.11
|
||||
# This file is autogenerated by pip-compile with Python 3.12
|
||||
# by the following command:
|
||||
#
|
||||
# pip-compile --generate-hashes requirements.in
|
||||
@ -8,6 +8,104 @@ attrs==20.3.0 \
|
||||
--hash=sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6 \
|
||||
--hash=sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700
|
||||
# via -r requirements.in
|
||||
certifi==2025.6.15 \
|
||||
--hash=sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057 \
|
||||
--hash=sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b
|
||||
# via requests
|
||||
charset-normalizer==3.4.2 \
|
||||
--hash=sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4 \
|
||||
--hash=sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45 \
|
||||
--hash=sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7 \
|
||||
--hash=sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0 \
|
||||
--hash=sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7 \
|
||||
--hash=sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d \
|
||||
--hash=sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d \
|
||||
--hash=sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0 \
|
||||
--hash=sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184 \
|
||||
--hash=sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db \
|
||||
--hash=sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b \
|
||||
--hash=sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64 \
|
||||
--hash=sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b \
|
||||
--hash=sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8 \
|
||||
--hash=sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff \
|
||||
--hash=sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344 \
|
||||
--hash=sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58 \
|
||||
--hash=sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e \
|
||||
--hash=sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471 \
|
||||
--hash=sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148 \
|
||||
--hash=sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a \
|
||||
--hash=sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836 \
|
||||
--hash=sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e \
|
||||
--hash=sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63 \
|
||||
--hash=sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c \
|
||||
--hash=sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1 \
|
||||
--hash=sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01 \
|
||||
--hash=sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366 \
|
||||
--hash=sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58 \
|
||||
--hash=sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5 \
|
||||
--hash=sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c \
|
||||
--hash=sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2 \
|
||||
--hash=sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a \
|
||||
--hash=sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597 \
|
||||
--hash=sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b \
|
||||
--hash=sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5 \
|
||||
--hash=sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb \
|
||||
--hash=sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f \
|
||||
--hash=sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0 \
|
||||
--hash=sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941 \
|
||||
--hash=sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0 \
|
||||
--hash=sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86 \
|
||||
--hash=sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7 \
|
||||
--hash=sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7 \
|
||||
--hash=sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455 \
|
||||
--hash=sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6 \
|
||||
--hash=sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4 \
|
||||
--hash=sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0 \
|
||||
--hash=sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3 \
|
||||
--hash=sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1 \
|
||||
--hash=sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6 \
|
||||
--hash=sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981 \
|
||||
--hash=sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c \
|
||||
--hash=sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980 \
|
||||
--hash=sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645 \
|
||||
--hash=sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7 \
|
||||
--hash=sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12 \
|
||||
--hash=sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa \
|
||||
--hash=sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd \
|
||||
--hash=sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef \
|
||||
--hash=sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f \
|
||||
--hash=sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2 \
|
||||
--hash=sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d \
|
||||
--hash=sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5 \
|
||||
--hash=sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02 \
|
||||
--hash=sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3 \
|
||||
--hash=sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd \
|
||||
--hash=sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e \
|
||||
--hash=sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214 \
|
||||
--hash=sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd \
|
||||
--hash=sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a \
|
||||
--hash=sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c \
|
||||
--hash=sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681 \
|
||||
--hash=sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba \
|
||||
--hash=sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f \
|
||||
--hash=sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a \
|
||||
--hash=sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28 \
|
||||
--hash=sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691 \
|
||||
--hash=sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82 \
|
||||
--hash=sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a \
|
||||
--hash=sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027 \
|
||||
--hash=sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7 \
|
||||
--hash=sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518 \
|
||||
--hash=sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf \
|
||||
--hash=sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b \
|
||||
--hash=sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9 \
|
||||
--hash=sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544 \
|
||||
--hash=sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da \
|
||||
--hash=sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509 \
|
||||
--hash=sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f \
|
||||
--hash=sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a \
|
||||
--hash=sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f
|
||||
# via requests
|
||||
gitdb==4.0.11 \
|
||||
--hash=sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4 \
|
||||
--hash=sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b
|
||||
@ -16,6 +114,10 @@ gitpython==3.1.41 \
|
||||
--hash=sha256:c36b6634d069b3f719610175020a9aed919421c87552185b085e04fbbdb10b7c \
|
||||
--hash=sha256:ed66e624884f76df22c8e16066d567aaa5a37d5b5fa19db2c6df6f7156db9048
|
||||
# via -r requirements.in
|
||||
idna==3.10 \
|
||||
--hash=sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9 \
|
||||
--hash=sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3
|
||||
# via requests
|
||||
importlib-metadata==3.7.0 \
|
||||
--hash=sha256:24499ffde1b80be08284100393955842be4a59c7c16bbf2738aad0e464a8e0aa \
|
||||
--hash=sha256:c6af5dbf1126cd959c4a8d8efd61d4d3c83bddb0459a17e554284a077574b614
|
||||
@ -155,6 +257,10 @@ pyyaml==6.0.1 \
|
||||
--hash=sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d \
|
||||
--hash=sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f
|
||||
# via -r requirements.in
|
||||
requests==2.32.4 \
|
||||
--hash=sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c \
|
||||
--hash=sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422
|
||||
# via -r requirements.in
|
||||
smmap==5.0.1 \
|
||||
--hash=sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62 \
|
||||
--hash=sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da
|
||||
@ -168,6 +274,10 @@ typing-extensions==3.7.4.3 \
|
||||
--hash=sha256:99d4073b617d30288f569d3f13d2bd7548c3a7e4c8de87db09a9d29bb3a4a60c \
|
||||
--hash=sha256:dafc7639cde7f1b6e1acc0f457842a83e722ccca8eef5270af2d74792619a89f
|
||||
# via -r requirements.in
|
||||
urllib3==2.5.0 \
|
||||
--hash=sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760 \
|
||||
--hash=sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc
|
||||
# via requests
|
||||
wget==3.2 \
|
||||
--hash=sha256:35e630eca2aa50ce998b9b1a127bb26b30dfee573702782aa982f875e3f16061
|
||||
# via -r requirements.in
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
{% set unary %}{% for family in instructions['sigs'] %}{% for scheme in family['schemes'] %}1{% endfor %}{% endfor %}{% endset %}
|
||||
{% set unary_alias %}{% for family in instructions['sigs'] %}{% for scheme in family['schemes'] if 'alias_scheme' in scheme %}2{% endfor %}{% endfor %}{% endset %}
|
||||
/** Number of algorithm identifiers above. */
|
||||
#define OQS_SIG_algs_length {{ unary|length + unary_alias|length }}
|
||||
#define OQS_SIG_algs_length {{ unary|length + unary_alias|length }} + OQS_SIG_SLH_DSA_algs_length
|
||||
|
||||
|
||||
@ -73,6 +73,11 @@ if(OQS_ENABLE_SIG_SNOVA)
|
||||
endif()
|
||||
##### OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_OBJECTS_END
|
||||
|
||||
if(OQS_ENABLE_SIG_SLH_DSA)
|
||||
add_subdirectory(sig/slh_dsa)
|
||||
set(SIG_OBJS ${SIG_OBJS} ${SLH_DSA_OBJS})
|
||||
endif()
|
||||
|
||||
if(OQS_ENABLE_SIG_STFL_XMSS)
|
||||
add_subdirectory(sig_stfl/xmss)
|
||||
set(SIG_STFL_OBJS ${SIG_STFL_OBJS} ${XMSS_OBJS})
|
||||
|
||||
@ -331,6 +331,165 @@
|
||||
#cmakedefine OQS_ENABLE_SIG_snova_SNOVA_29_6_5_avx2 1
|
||||
#cmakedefine OQS_ENABLE_SIG_snova_SNOVA_29_6_5_neon 1
|
||||
///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START
|
||||
#cmakedefine OQS_ENABLE_SIG_SLH_DSA 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_pure_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192f 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256s 1
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256f 1
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END
|
||||
|
||||
///// OQS_COPY_FROM_LIBJADE_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START
|
||||
|
||||
|
||||
2034
src/sig/sig.c
2034
src/sig/sig.c
File diff suppressed because it is too large
Load Diff
326
src/sig/sig.h
326
src/sig/sig.h
@ -169,11 +169,330 @@ extern "C" {
|
||||
/** Algorithm identifier for SNOVA_29_6_5 */
|
||||
#define OQS_SIG_alg_snova_SNOVA_29_6_5 "SNOVA_29_6_5"
|
||||
///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_END
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_START
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_128s "SLH_DSA_PURE_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_128f "SLH_DSA_PURE_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_192s "SLH_DSA_PURE_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_192f "SLH_DSA_PURE_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_256s "SLH_DSA_PURE_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_pure_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_sha2_256f "SLH_DSA_PURE_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_128s "SLH_DSA_PURE_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_128f "SLH_DSA_PURE_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_192s "SLH_DSA_PURE_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_192f "SLH_DSA_PURE_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_256s "SLH_DSA_PURE_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_pure_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_pure_shake_256f "SLH_DSA_PURE_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128s "SLH_DSA_SHA2_224_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128f "SLH_DSA_SHA2_224_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192s "SLH_DSA_SHA2_224_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192f "SLH_DSA_SHA2_224_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256s "SLH_DSA_SHA2_224_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256f "SLH_DSA_SHA2_224_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128s "SLH_DSA_SHA2_224_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128f "SLH_DSA_SHA2_224_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192s "SLH_DSA_SHA2_224_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192f "SLH_DSA_SHA2_224_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256s "SLH_DSA_SHA2_224_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256f "SLH_DSA_SHA2_224_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128s "SLH_DSA_SHA2_256_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128f "SLH_DSA_SHA2_256_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192s "SLH_DSA_SHA2_256_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192f "SLH_DSA_SHA2_256_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256s "SLH_DSA_SHA2_256_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256f "SLH_DSA_SHA2_256_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128s "SLH_DSA_SHA2_256_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128f "SLH_DSA_SHA2_256_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192s "SLH_DSA_SHA2_256_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192f "SLH_DSA_SHA2_256_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256s "SLH_DSA_SHA2_256_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256f "SLH_DSA_SHA2_256_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128s "SLH_DSA_SHA2_384_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128f "SLH_DSA_SHA2_384_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192s "SLH_DSA_SHA2_384_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192f "SLH_DSA_SHA2_384_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256s "SLH_DSA_SHA2_384_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256f "SLH_DSA_SHA2_384_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128s "SLH_DSA_SHA2_384_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128f "SLH_DSA_SHA2_384_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192s "SLH_DSA_SHA2_384_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192f "SLH_DSA_SHA2_384_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256s "SLH_DSA_SHA2_384_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256f "SLH_DSA_SHA2_384_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128s "SLH_DSA_SHA2_512_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128f "SLH_DSA_SHA2_512_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192s "SLH_DSA_SHA2_512_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192f "SLH_DSA_SHA2_512_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256s "SLH_DSA_SHA2_512_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256f "SLH_DSA_SHA2_512_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128s "SLH_DSA_SHA2_512_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128f "SLH_DSA_SHA2_512_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192s "SLH_DSA_SHA2_512_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192f "SLH_DSA_SHA2_512_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256s "SLH_DSA_SHA2_512_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256f "SLH_DSA_SHA2_512_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128s "SLH_DSA_SHA3_224_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128f "SLH_DSA_SHA3_224_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192s "SLH_DSA_SHA3_224_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192f "SLH_DSA_SHA3_224_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256s "SLH_DSA_SHA3_224_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256f "SLH_DSA_SHA3_224_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128s "SLH_DSA_SHA3_224_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128f "SLH_DSA_SHA3_224_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192s "SLH_DSA_SHA3_224_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192f "SLH_DSA_SHA3_224_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256s "SLH_DSA_SHA3_224_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256f "SLH_DSA_SHA3_224_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128s "SLH_DSA_SHA3_256_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128f "SLH_DSA_SHA3_256_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192s "SLH_DSA_SHA3_256_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192f "SLH_DSA_SHA3_256_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256s "SLH_DSA_SHA3_256_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256f "SLH_DSA_SHA3_256_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128s "SLH_DSA_SHA3_256_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128f "SLH_DSA_SHA3_256_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192s "SLH_DSA_SHA3_256_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192f "SLH_DSA_SHA3_256_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256s "SLH_DSA_SHA3_256_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256f "SLH_DSA_SHA3_256_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128s "SLH_DSA_SHA3_384_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128f "SLH_DSA_SHA3_384_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192s "SLH_DSA_SHA3_384_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192f "SLH_DSA_SHA3_384_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256s "SLH_DSA_SHA3_384_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256f "SLH_DSA_SHA3_384_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128s "SLH_DSA_SHA3_384_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128f "SLH_DSA_SHA3_384_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192s "SLH_DSA_SHA3_384_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192f "SLH_DSA_SHA3_384_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256s "SLH_DSA_SHA3_384_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256f "SLH_DSA_SHA3_384_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128s "SLH_DSA_SHA3_512_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128f "SLH_DSA_SHA3_512_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192s "SLH_DSA_SHA3_512_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192f "SLH_DSA_SHA3_512_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256s "SLH_DSA_SHA3_512_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256f "SLH_DSA_SHA3_512_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128s "SLH_DSA_SHA3_512_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128f "SLH_DSA_SHA3_512_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192s "SLH_DSA_SHA3_512_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192f "SLH_DSA_SHA3_512_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256s "SLH_DSA_SHA3_512_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256f "SLH_DSA_SHA3_512_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128s "SLH_DSA_SHAKE_128_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128f "SLH_DSA_SHAKE_128_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192s "SLH_DSA_SHAKE_128_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192f "SLH_DSA_SHAKE_128_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256s "SLH_DSA_SHAKE_128_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256f "SLH_DSA_SHAKE_128_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128s "SLH_DSA_SHAKE_256_PREHASH_SHA2_128S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128f "SLH_DSA_SHAKE_256_PREHASH_SHA2_128F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192s "SLH_DSA_SHAKE_256_PREHASH_SHA2_192S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192f "SLH_DSA_SHAKE_256_PREHASH_SHA2_192F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256s "SLH_DSA_SHAKE_256_PREHASH_SHA2_256S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256f "SLH_DSA_SHAKE_256_PREHASH_SHA2_256F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192F"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256s */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256S"
|
||||
/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256f */
|
||||
#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256F"
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_END
|
||||
// EDIT-WHEN-ADDING-SIG
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_START
|
||||
|
||||
/** Number of algorithm identifiers above. */
|
||||
#define OQS_SIG_SLH_DSA_algs_length 156
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_END
|
||||
///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_START
|
||||
|
||||
/** Number of algorithm identifiers above. */
|
||||
#define OQS_SIG_algs_length 68
|
||||
#define OQS_SIG_algs_length 68 + OQS_SIG_SLH_DSA_algs_length
|
||||
///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_END
|
||||
|
||||
/**
|
||||
@ -446,6 +765,11 @@ OQS_API bool OQS_SIG_supports_ctx_str(const char *alg_name);
|
||||
#include <oqs/sig_snova.h>
|
||||
#endif /* OQS_ENABLE_SIG_SNOVA */
|
||||
///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_END
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_START
|
||||
#ifdef OQS_ENABLE_SIG_SLH_DSA
|
||||
#include <oqs/sig_slh_dsa.h>
|
||||
#endif /* OQS_ENABLE_SIG_SLH_DSA */
|
||||
///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_END
|
||||
// EDIT-WHEN-ADDING-SIG
|
||||
|
||||
#if defined(__cplusplus)
|
||||
|
||||
191
src/sig/slh_dsa/CMakeLists.txt
Normal file
191
src/sig/slh_dsa/CMakeLists.txt
Normal file
@ -0,0 +1,191 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
|
||||
set(_SLH_DSA_OBJS "")
|
||||
|
||||
if(OQS_ENABLE_SIG_SLH_DSA)
|
||||
add_library(slh_dsa_c OBJECT
|
||||
slh_dsa_c/slh_sha2.c
|
||||
slh_dsa_c/slh_dsa.c
|
||||
slh_dsa_c/sha3_f1600.c
|
||||
slh_dsa_c/sha2_256.c
|
||||
slh_dsa_c/sha2_512.c
|
||||
slh_dsa_c/slh_shake.c
|
||||
slh_dsa_c/sha3_api.c
|
||||
slh_dsa_c/slh_prehash.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_128f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_128s.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_192f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_256f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_256s.c
|
||||
wrappers/prehash_sha3_224/slh_dsa_sha3_224_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_224/slh_dsa_sha2_224_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_512_256/slh_dsa_sha2_512_256_prehash_sha2_256f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_128s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_192s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_256s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_256f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_192f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_128f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_256s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_192s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_128s.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_sha2_128f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_192f.c
|
||||
wrappers/prehash_shake_128/slh_dsa_shake_128_prehash_shake_256f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_128s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_128f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_192s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_256s.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_256f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_shake_192f.c
|
||||
wrappers/prehash_sha3_512/slh_dsa_sha3_512_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_512/slh_dsa_sha2_512_prehash_sha2_192f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_192s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_256s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_192f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_256f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_256s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_192s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_256f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_192f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_128s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_128f.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_sha2_128s.c
|
||||
wrappers/prehash_shake_256/slh_dsa_shake_256_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_384/slh_dsa_sha2_384_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_128s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_128f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_256s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_192s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_192f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha3_384/slh_dsa_sha3_384_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_192s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_512_224/slh_dsa_sha2_512_224_prehash_shake_128f.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_192s.c
|
||||
wrappers/pure/slh_dsa_pure_shake_192s.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_256s.c
|
||||
wrappers/pure/slh_dsa_pure_shake_256s.c
|
||||
wrappers/pure/slh_dsa_pure_shake_256f.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_256f.c
|
||||
wrappers/pure/slh_dsa_pure_shake_192f.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_192f.c
|
||||
wrappers/pure/slh_dsa_pure_shake_128s.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_128s.c
|
||||
wrappers/pure/slh_dsa_pure_sha2_128f.c
|
||||
wrappers/pure/slh_dsa_pure_shake_128f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_128f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_128s.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_192f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_192f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_256f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_256s.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha2_256/slh_dsa_sha2_256_prehash_shake_192s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_128s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_128s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_128f.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_128f.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_192s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_256s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_256s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_192s.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_192f.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_shake_256f.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_256f.c
|
||||
wrappers/prehash_sha3_256/slh_dsa_sha3_256_prehash_sha2_192f.c
|
||||
|
||||
)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/slh_dsa_c)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/pure)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_224)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_256)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_384)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_512)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_512_224)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha2_512_256)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha3_224)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha3_256)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha3_384)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_sha3_512)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_shake_128)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_shake_256)
|
||||
|
||||
set(_SLH_DSA_OBJS ${_SLH_DSA_OBJS} $<TARGET_OBJECTS:slh_dsa_c>)
|
||||
endif()
|
||||
|
||||
set(SLH_DSA_OBJS ${_SLH_DSA_OBJS} PARENT_SCOPE)
|
||||
2192
src/sig/slh_dsa/sig_slh_dsa.h
Normal file
2192
src/sig/slh_dsa/sig_slh_dsa.h
Normal file
File diff suppressed because it is too large
Load Diff
88
src/sig/slh_dsa/slh_dsa_c/integration/liboqs/META.yml
Normal file
88
src/sig/slh_dsa/slh_dsa_c/integration/liboqs/META.yml
Normal file
@ -0,0 +1,88 @@
|
||||
algDetails:
|
||||
algVersion: FIPS205
|
||||
claimedNISTLevel: 1
|
||||
eufCMA: 'true'
|
||||
sufCMA: 'true'
|
||||
|
||||
sources:
|
||||
integration/liboqs/META.yml
|
||||
plat_local.h
|
||||
sha2_256.c
|
||||
sha2_512.c
|
||||
sha2_api.h
|
||||
sha3_api.c
|
||||
sha3_api.h
|
||||
sha3_f1600.c
|
||||
slh_adrs.h
|
||||
slh_dsa.c
|
||||
slh_dsa.h
|
||||
slh_param.h
|
||||
slh_prehash.c
|
||||
slh_prehash.h
|
||||
slh_sha2.c
|
||||
slh_shake.c
|
||||
slh_var.h
|
||||
|
||||
paramSets:
|
||||
-
|
||||
name: 128s
|
||||
pkSize: 32
|
||||
skSize: 64
|
||||
sigSize: 7856
|
||||
-
|
||||
name: 128f
|
||||
pkSize: 32
|
||||
skSize: 64
|
||||
sigSize: 17088
|
||||
-
|
||||
name: 192s
|
||||
pkSize: 48
|
||||
skSize: 96
|
||||
sigSize: 16224
|
||||
-
|
||||
name: 192f
|
||||
pkSize: 48
|
||||
skSize: 96
|
||||
sigSize: 35664
|
||||
-
|
||||
name: 256s
|
||||
pkSize: 64
|
||||
skSize: 128
|
||||
sigSize: 29792
|
||||
-
|
||||
name: 256f
|
||||
pkSize: 64
|
||||
skSize: 128
|
||||
sigSize: 49856
|
||||
|
||||
hashAlgs:
|
||||
-
|
||||
name: sha2
|
||||
-
|
||||
name: shake
|
||||
|
||||
prehashHashAlgs:
|
||||
-
|
||||
name: sha2_224
|
||||
-
|
||||
name: sha2_256
|
||||
-
|
||||
name: sha2_384
|
||||
-
|
||||
name: sha2_512
|
||||
-
|
||||
name: sha2_512_224
|
||||
-
|
||||
name: sha2_512_256
|
||||
-
|
||||
name: sha3_224
|
||||
-
|
||||
name: sha3_256
|
||||
-
|
||||
name: sha3_384
|
||||
-
|
||||
name: sha3_512
|
||||
-
|
||||
name: shake_128
|
||||
-
|
||||
name: shake_256
|
||||
265
src/sig/slh_dsa/slh_dsa_c/plat_local.h
Normal file
265
src/sig/slh_dsa/slh_dsa_c/plat_local.h
Normal file
@ -0,0 +1,265 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Localization affecting all implementations can be inserted here. */
|
||||
|
||||
#ifndef _PLAT_LOCAL_H_
|
||||
#define _PLAT_LOCAL_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifndef PLAT_VERS_STR
|
||||
#define PLAT_VERS_STR "dev version"
|
||||
#define PLAT_VERS_MAJ 0
|
||||
#define PLAT_VERS_MIN 0
|
||||
#endif
|
||||
|
||||
/* === platform detection logic */
|
||||
|
||||
#ifndef PLAT_XLEN
|
||||
|
||||
#if defined(__riscv)
|
||||
|
||||
#define PLAT_XLEN __riscv_xlen
|
||||
#if defined(__riscv_vector)
|
||||
#define PLAT_ARCH_RVV
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_RVV"
|
||||
#elif (__riscv_xlen == 32)
|
||||
#define PLAT_ARCH_RV32
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_RV32"
|
||||
#else
|
||||
#define PLAT_ARCH_RV64
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_RV64"
|
||||
#endif
|
||||
|
||||
#elif defined(__arm__)
|
||||
#define PLAT_XLEN 32
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_ARM32"
|
||||
#define PLAT_ARCH_ARM32
|
||||
|
||||
#elif defined(__aarch64__)
|
||||
#define PLAT_XLEN 64
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_ARM64"
|
||||
#define PLAT_ARCH_ARM64
|
||||
|
||||
#elif defined(__i386__)
|
||||
#define PLAT_XLEN 32
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_IA32"
|
||||
#define PLAT_ARCH_IA32
|
||||
|
||||
#elif defined(__x86_64__)
|
||||
#define PLAT_XLEN 64
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_X64"
|
||||
#define PLAT_ARCH_X64
|
||||
|
||||
#elif (__WORDSIZE == 32)
|
||||
#define PLAT_XLEN 32
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_GEN32"
|
||||
#define PLAT_ARCH_GEN32
|
||||
|
||||
#else
|
||||
/* fallback for everything */
|
||||
#define PLAT_XLEN 64
|
||||
#define PLAT_ARCH_STR "PLAT_ARCH_GEN64"
|
||||
#define PLAT_ARCH_GEN64
|
||||
#endif
|
||||
|
||||
/* PLAT_XLEN signals that the rest of the macros are defined too */
|
||||
#endif
|
||||
|
||||
/* === Assume-Assert checks */
|
||||
|
||||
/* No-op for production */
|
||||
#ifndef __CPROVER__
|
||||
|
||||
#ifndef XDEBUG
|
||||
#define XASSERT(x)
|
||||
#define XASSUME(x)
|
||||
#define XTMPVAR(x)
|
||||
|
||||
/* Runtime checks in debug build */
|
||||
#else
|
||||
#include <assert.h>
|
||||
#define XASSERT(x) assert(x)
|
||||
#define XASSUME(x) assert(x)
|
||||
#define XTMPVAR(x) x
|
||||
/* XDEBUG */
|
||||
#endif
|
||||
|
||||
/* For CBMC (formal checks) */
|
||||
#else
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#define XASSERT(x) assert(x)
|
||||
#define XASSUME(x) __CPROVER_assume(x)
|
||||
#define XTMPVAR(x) x
|
||||
#define XPROOFS
|
||||
#endif /* __CPROVER__ */
|
||||
|
||||
/* revert if not big endian */
|
||||
|
||||
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
|
||||
/* nop */
|
||||
#define rev8_be32(x) (x)
|
||||
#else
|
||||
/* RISC-V: grev(x, 0x18) or rev8 */
|
||||
|
||||
static inline uint32_t rev8_be32(uint32_t x)
|
||||
{
|
||||
return ((x & 0xFF000000) >> 24) | ((x & 0x00FF0000) >> 8) |
|
||||
((x & 0x0000FF00) << 8) | ((x & 0x000000FF) << 24);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
|
||||
#define rev8_be64(x) (x)
|
||||
#else
|
||||
/* RISC-V: grev(x, 0x38) or rev8(x) */
|
||||
static inline uint64_t rev8_be64(uint64_t x)
|
||||
{
|
||||
return (x << 56) | ((x & 0x000000000000FF00LL) << 40) |
|
||||
((x & 0x0000000000FF0000LL) << 24) |
|
||||
((x & 0x00000000FF000000LL) << 8) | ((x & 0x000000FF00000000LL) >> 8) |
|
||||
((x & 0x0000FF0000000000LL) >> 24) |
|
||||
((x & 0x00FF000000000000LL) >> 40) | (x >> 56);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* rotate left */
|
||||
|
||||
static inline uint32_t rol32(uint32_t x, uint32_t n)
|
||||
{
|
||||
return (x << n) | (x >> (32 - n));
|
||||
}
|
||||
|
||||
static inline uint64_t rol64(uint64_t x, uint64_t n)
|
||||
{
|
||||
return (x << n) | (x >> (64 - n));
|
||||
}
|
||||
|
||||
/* rotate right (RISC-V ROR or RORI) */
|
||||
|
||||
static inline uint32_t ror32(uint32_t x, uint32_t n)
|
||||
{
|
||||
return (x >> n) | (x << (32 - n));
|
||||
}
|
||||
|
||||
static inline uint64_t ror64(uint64_t x, uint64_t n)
|
||||
{
|
||||
return (x >> n) | (x << (64 - n));
|
||||
}
|
||||
|
||||
/* and with negate (RISC-V ANDN) */
|
||||
|
||||
static inline uint32_t andn32(uint32_t x, uint32_t y) { return x & ~y; }
|
||||
|
||||
static inline uint64_t andn64(uint64_t x, uint64_t y) { return x & ~y; }
|
||||
|
||||
/* little-endian loads and stores (unaligned) */
|
||||
|
||||
static inline uint16_t get16u_le(const uint8_t *v)
|
||||
{
|
||||
return (((uint16_t)v[1]) << 8) | ((uint16_t)v[0]);
|
||||
}
|
||||
|
||||
static inline void put16u_le(uint8_t *v, uint16_t x)
|
||||
{
|
||||
v[0] = x;
|
||||
v[1] = x >> 8;
|
||||
}
|
||||
|
||||
static inline uint32_t get32u_le(const uint8_t *v)
|
||||
{
|
||||
return ((uint32_t)v[0]) | (((uint32_t)v[1]) << 8) |
|
||||
(((uint32_t)v[2]) << 16) | (((uint32_t)v[3]) << 24);
|
||||
}
|
||||
|
||||
static inline void put32u_le(uint8_t *v, uint32_t x)
|
||||
{
|
||||
v[0] = x;
|
||||
v[1] = x >> 8;
|
||||
v[2] = x >> 16;
|
||||
v[3] = x >> 24;
|
||||
}
|
||||
|
||||
static inline uint64_t get64u_le(const uint8_t *v)
|
||||
{
|
||||
return ((uint64_t)v[0]) | (((uint64_t)v[1]) << 8) |
|
||||
(((uint64_t)v[2]) << 16) | (((uint64_t)v[3]) << 24) |
|
||||
(((uint64_t)v[4]) << 32) | (((uint64_t)v[5]) << 40) |
|
||||
(((uint64_t)v[6]) << 48) | (((uint64_t)v[7]) << 56);
|
||||
}
|
||||
|
||||
static inline void put64u_le(uint8_t *v, uint64_t x)
|
||||
{
|
||||
v[0] = x;
|
||||
v[1] = x >> 8;
|
||||
v[2] = x >> 16;
|
||||
v[3] = x >> 24;
|
||||
v[4] = x >> 32;
|
||||
v[5] = x >> 40;
|
||||
v[6] = x >> 48;
|
||||
v[7] = x >> 56;
|
||||
}
|
||||
|
||||
/* big-endian loads and stores (unaligned) */
|
||||
|
||||
static inline uint16_t get16u_be(const uint8_t *v)
|
||||
{
|
||||
return (((uint16_t)v[0]) << 8) | ((uint16_t)v[1]);
|
||||
}
|
||||
|
||||
static inline void put16u_be(uint8_t *v, uint16_t x)
|
||||
{
|
||||
v[0] = x >> 8;
|
||||
v[1] = x;
|
||||
}
|
||||
|
||||
static inline uint32_t get32u_be(const uint8_t *v)
|
||||
{
|
||||
return (((uint32_t)v[0]) << 24) | (((uint32_t)v[1]) << 16) |
|
||||
(((uint32_t)v[2]) << 8) | ((uint32_t)v[3]);
|
||||
}
|
||||
|
||||
static inline void put32u_be(uint8_t *v, uint32_t x)
|
||||
{
|
||||
v[0] = x >> 24;
|
||||
v[1] = x >> 16;
|
||||
v[2] = x >> 8;
|
||||
v[3] = x;
|
||||
}
|
||||
|
||||
static inline uint64_t get64u_be(const uint8_t *v)
|
||||
{
|
||||
return (((uint64_t)v[0]) << 56) | (((uint64_t)v[1]) << 48) |
|
||||
(((uint64_t)v[2]) << 40) | (((uint64_t)v[3]) << 32) |
|
||||
(((uint64_t)v[4]) << 24) | (((uint64_t)v[5]) << 16) |
|
||||
(((uint64_t)v[6]) << 8) | ((uint64_t)v[7]);
|
||||
}
|
||||
|
||||
static inline void put64u_be(uint8_t *v, uint64_t x)
|
||||
{
|
||||
v[0] = x >> 56;
|
||||
v[1] = x >> 48;
|
||||
v[2] = x >> 40;
|
||||
v[3] = x >> 32;
|
||||
v[4] = x >> 24;
|
||||
v[5] = x >> 16;
|
||||
v[6] = x >> 8;
|
||||
v[7] = x;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* _PLAT_LOCAL_H_ */
|
||||
#endif
|
||||
271
src/sig/slh_dsa/slh_dsa_c/sha2_256.c
Normal file
271
src/sig/slh_dsa/slh_dsa_c/sha2_256.c
Normal file
@ -0,0 +1,271 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 180-4 SHA2-256 / Portable C Implementation */
|
||||
|
||||
#include <string.h>
|
||||
#include "plat_local.h"
|
||||
#include "sha2_api.h"
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
uint64_t sha2_256_compress_count = 0; /* instrumentation */
|
||||
#endif
|
||||
|
||||
/* processing step, sets "d" and "h" as a function of all 8 inputs */
|
||||
/* and message schedule "mi", round constant "ki" */
|
||||
#define STEP_SHA256_R(a, b, c, d, e, f, g, h, mi, ki) \
|
||||
{ \
|
||||
h += (g ^ (e & (f ^ g))) + mi + ki + \
|
||||
(ror32(e, 6) ^ ror32(e, 11) ^ ror32(e, 25)); \
|
||||
d += h; \
|
||||
h += (((a | c) & b) | (c & a)) + \
|
||||
(ror32(a, 2) ^ ror32(a, 13) ^ ror32(a, 22)); \
|
||||
}
|
||||
|
||||
/* keying step, sets x0 as a function of 4 inputs */
|
||||
#define STEP_SHA256_K(x0, x1, x9, xe) \
|
||||
{ \
|
||||
x0 += x9 + (ror32(x1, 7) ^ ror32(x1, 18) ^ (x1 >> 3)) + \
|
||||
(ror32(xe, 17) ^ ror32(xe, 19) ^ (xe >> 10)); \
|
||||
}
|
||||
|
||||
void sha2_256_compress(void *v)
|
||||
{
|
||||
/* 4.2.2 SHA-224 and SHA-256 Constants */
|
||||
|
||||
const uint32_t ck[64] = {
|
||||
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1,
|
||||
0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
|
||||
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786,
|
||||
0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
|
||||
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147,
|
||||
0x06CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
|
||||
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B,
|
||||
0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
|
||||
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A,
|
||||
0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
|
||||
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2};
|
||||
|
||||
uint32_t a, b, c, d, e, f, g, h;
|
||||
uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, ma, mb, mc, md, me, mf;
|
||||
|
||||
uint32_t *sp = (uint32_t *)v;
|
||||
const uint32_t *mp = sp + 8;
|
||||
const uint32_t *kp = ck;
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
sha2_256_compress_count++; /* instrumentation */
|
||||
#endif
|
||||
|
||||
a = sp[0] = rev8_be32(sp[0]);
|
||||
b = sp[1] = rev8_be32(sp[1]);
|
||||
c = sp[2] = rev8_be32(sp[2]);
|
||||
d = sp[3] = rev8_be32(sp[3]);
|
||||
e = sp[4] = rev8_be32(sp[4]);
|
||||
f = sp[5] = rev8_be32(sp[5]);
|
||||
g = sp[6] = rev8_be32(sp[6]);
|
||||
h = sp[7] = rev8_be32(sp[7]);
|
||||
|
||||
/* load and reverse bytes (if needed) */
|
||||
|
||||
m0 = rev8_be32(mp[0]);
|
||||
m1 = rev8_be32(mp[1]);
|
||||
m2 = rev8_be32(mp[2]);
|
||||
m3 = rev8_be32(mp[3]);
|
||||
m4 = rev8_be32(mp[4]);
|
||||
m5 = rev8_be32(mp[5]);
|
||||
m6 = rev8_be32(mp[6]);
|
||||
m7 = rev8_be32(mp[7]);
|
||||
m8 = rev8_be32(mp[8]);
|
||||
m9 = rev8_be32(mp[9]);
|
||||
ma = rev8_be32(mp[10]);
|
||||
mb = rev8_be32(mp[11]);
|
||||
mc = rev8_be32(mp[12]);
|
||||
md = rev8_be32(mp[13]);
|
||||
me = rev8_be32(mp[14]);
|
||||
mf = rev8_be32(mp[15]);
|
||||
|
||||
while (1)
|
||||
{
|
||||
STEP_SHA256_R(a, b, c, d, e, f, g, h, m0, kp[0]); /* rounds */
|
||||
STEP_SHA256_R(h, a, b, c, d, e, f, g, m1, kp[1]);
|
||||
STEP_SHA256_R(g, h, a, b, c, d, e, f, m2, kp[2]);
|
||||
STEP_SHA256_R(f, g, h, a, b, c, d, e, m3, kp[3]);
|
||||
STEP_SHA256_R(e, f, g, h, a, b, c, d, m4, kp[4]);
|
||||
STEP_SHA256_R(d, e, f, g, h, a, b, c, m5, kp[5]);
|
||||
STEP_SHA256_R(c, d, e, f, g, h, a, b, m6, kp[6]);
|
||||
STEP_SHA256_R(b, c, d, e, f, g, h, a, m7, kp[7]);
|
||||
STEP_SHA256_R(a, b, c, d, e, f, g, h, m8, kp[8]);
|
||||
STEP_SHA256_R(h, a, b, c, d, e, f, g, m9, kp[9]);
|
||||
STEP_SHA256_R(g, h, a, b, c, d, e, f, ma, kp[10]);
|
||||
STEP_SHA256_R(f, g, h, a, b, c, d, e, mb, kp[11]);
|
||||
STEP_SHA256_R(e, f, g, h, a, b, c, d, mc, kp[12]);
|
||||
STEP_SHA256_R(d, e, f, g, h, a, b, c, md, kp[13]);
|
||||
STEP_SHA256_R(c, d, e, f, g, h, a, b, me, kp[14]);
|
||||
STEP_SHA256_R(b, c, d, e, f, g, h, a, mf, kp[15]);
|
||||
|
||||
if (kp == &ck[64 - 16])
|
||||
{
|
||||
break;
|
||||
}
|
||||
kp += 16;
|
||||
|
||||
STEP_SHA256_K(m0, m1, m9, me); /* message schedule */
|
||||
STEP_SHA256_K(m1, m2, ma, mf);
|
||||
STEP_SHA256_K(m2, m3, mb, m0);
|
||||
STEP_SHA256_K(m3, m4, mc, m1);
|
||||
STEP_SHA256_K(m4, m5, md, m2);
|
||||
STEP_SHA256_K(m5, m6, me, m3);
|
||||
STEP_SHA256_K(m6, m7, mf, m4);
|
||||
STEP_SHA256_K(m7, m8, m0, m5);
|
||||
STEP_SHA256_K(m8, m9, m1, m6);
|
||||
STEP_SHA256_K(m9, ma, m2, m7);
|
||||
STEP_SHA256_K(ma, mb, m3, m8);
|
||||
STEP_SHA256_K(mb, mc, m4, m9);
|
||||
STEP_SHA256_K(mc, md, m5, ma);
|
||||
STEP_SHA256_K(md, me, m6, mb);
|
||||
STEP_SHA256_K(me, mf, m7, mc);
|
||||
STEP_SHA256_K(mf, m0, m8, md);
|
||||
}
|
||||
|
||||
sp[0] = rev8_be32(sp[0] + a);
|
||||
sp[1] = rev8_be32(sp[1] + b);
|
||||
sp[2] = rev8_be32(sp[2] + c);
|
||||
sp[3] = rev8_be32(sp[3] + d);
|
||||
sp[4] = rev8_be32(sp[4] + e);
|
||||
sp[5] = rev8_be32(sp[5] + f);
|
||||
sp[6] = rev8_be32(sp[6] + g);
|
||||
sp[7] = rev8_be32(sp[7] + h);
|
||||
}
|
||||
|
||||
/* initialize */
|
||||
|
||||
static void sha2_256_init_h0(sha2_256_t *sha, const uint8_t *h0)
|
||||
{
|
||||
memcpy(sha->s, h0, 32);
|
||||
sha->i = 0;
|
||||
sha->len = 0;
|
||||
}
|
||||
|
||||
void sha2_256_init(sha2_256_t *sha)
|
||||
{
|
||||
/* SHA-256 initial values H0, Sect 5.3.3. */
|
||||
const uint8_t sha2_256_h0[32] = {
|
||||
0x6A, 0x09, 0xE6, 0x67, 0xBB, 0x67, 0xAE, 0x85, 0x3C, 0x6E, 0xF3,
|
||||
0x72, 0xA5, 0x4F, 0xF5, 0x3A, 0x51, 0x0E, 0x52, 0x7F, 0x9B, 0x05,
|
||||
0x68, 0x8C, 0x1F, 0x83, 0xD9, 0xAB, 0x5B, 0xE0, 0xCD, 0x19};
|
||||
|
||||
sha2_256_init_h0(sha, sha2_256_h0);
|
||||
}
|
||||
|
||||
void sha2_224_init(sha2_256_t *sha)
|
||||
{
|
||||
/* SHA-224 initial values H0, Sect 5.3.2. */
|
||||
const uint8_t sha2_224_h0[32] = {
|
||||
0xC1, 0x05, 0x9E, 0xD8, 0x36, 0x7C, 0xD5, 0x07, 0x30, 0x70, 0xDD,
|
||||
0x17, 0xF7, 0x0E, 0x59, 0x39, 0xFF, 0xC0, 0x0B, 0x31, 0x68, 0x58,
|
||||
0x15, 0x11, 0x64, 0xF9, 0x8F, 0xA7, 0xBE, 0xFA, 0x4F, 0xA4};
|
||||
|
||||
sha2_256_init_h0(sha, sha2_224_h0);
|
||||
}
|
||||
|
||||
void sha2_256_copy(sha2_256_t *dst, const sha2_256_t *src)
|
||||
{
|
||||
dst->i = src->i;
|
||||
dst->len = src->len;
|
||||
memcpy(dst->s, src->s, 32 + src->i);
|
||||
}
|
||||
|
||||
/* SHA2-256 process input */
|
||||
|
||||
void sha2_256_update(sha2_256_t *sha, const uint8_t *m, size_t m_sz)
|
||||
{
|
||||
size_t l;
|
||||
uint8_t *mp = (uint8_t *)&sha->s[8];
|
||||
|
||||
sha->len += m_sz;
|
||||
l = 64 - sha->i;
|
||||
|
||||
if (m_sz < l)
|
||||
{
|
||||
memcpy(mp + sha->i, m, m_sz);
|
||||
sha->i += m_sz;
|
||||
return;
|
||||
}
|
||||
if (sha->i > 0)
|
||||
{
|
||||
memcpy(mp + sha->i, m, l);
|
||||
sha2_256_compress(sha->s);
|
||||
m_sz -= l;
|
||||
m += l;
|
||||
sha->i = 0;
|
||||
}
|
||||
while (m_sz >= 64)
|
||||
{
|
||||
memcpy(mp, m, 64);
|
||||
sha2_256_compress(sha->s);
|
||||
m_sz -= 64;
|
||||
m += 64;
|
||||
}
|
||||
memcpy(mp, m, m_sz);
|
||||
sha->i = m_sz;
|
||||
}
|
||||
|
||||
/* perform final padding */
|
||||
|
||||
void sha2_256_final_pad(sha2_256_t *sha)
|
||||
{
|
||||
uint8_t *mp = (uint8_t *)&sha->s[8];
|
||||
uint64_t x;
|
||||
size_t i;
|
||||
|
||||
i = sha->i; /* last data block */
|
||||
mp[i++] = 0x80;
|
||||
if (i > 56)
|
||||
{
|
||||
memset(mp + i, 0x00, 64 - i);
|
||||
sha2_256_compress(sha->s);
|
||||
i = 0;
|
||||
}
|
||||
memset(mp + i, 0x00, 64 - i); /* clear rest */
|
||||
|
||||
x = ((uint64_t)sha->len) << 3; /* process length */
|
||||
i = 64;
|
||||
while (x > 0)
|
||||
{
|
||||
mp[--i] = x & 0xFF;
|
||||
x >>= 8;
|
||||
}
|
||||
}
|
||||
|
||||
/* produce h_sz byte hash */
|
||||
|
||||
void sha2_256_final_len(sha2_256_t *sha, uint8_t *h, size_t h_sz)
|
||||
{
|
||||
sha2_256_final_pad(sha);
|
||||
sha2_256_compress(sha->s);
|
||||
|
||||
memcpy(h, sha->s, h_sz);
|
||||
}
|
||||
|
||||
/* SHA-224/256 public single-call interfaces */
|
||||
|
||||
void sha2_256(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_256_t sha;
|
||||
|
||||
sha2_256_init(&sha);
|
||||
sha2_256_update(&sha, m, m_sz);
|
||||
sha2_256_final(&sha, h);
|
||||
}
|
||||
|
||||
void sha2_224(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_256_t sha;
|
||||
|
||||
sha2_224_init(&sha);
|
||||
sha2_224_update(&sha, m, m_sz);
|
||||
sha2_224_final(&sha, h);
|
||||
}
|
||||
355
src/sig/slh_dsa/slh_dsa_c/sha2_512.c
Normal file
355
src/sig/slh_dsa/slh_dsa_c/sha2_512.c
Normal file
@ -0,0 +1,355 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 180-4 SHA2-512 / Portable C Implementation */
|
||||
|
||||
#include <string.h>
|
||||
#include "plat_local.h"
|
||||
#include "sha2_api.h"
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
uint64_t sha2_512_compress_count = 0; /* instrumentation */
|
||||
#endif
|
||||
|
||||
/* processing step, sets "d" and "h" as a function of all 8 inputs */
|
||||
/* and message schedule "mi", round constant "ki" */
|
||||
#define STEP_SHA512_R(a, b, c, d, e, f, g, h, mi, ki) \
|
||||
{ \
|
||||
h += (g ^ (e & (f ^ g))) + mi + ki + \
|
||||
(ror64(e, 14) ^ ror64(e, 18) ^ ror64(e, 41)); \
|
||||
d += h; \
|
||||
h += (((a | c) & b) | (c & a)) + \
|
||||
(ror64(a, 28) ^ ror64(a, 34) ^ ror64(a, 39)); \
|
||||
}
|
||||
|
||||
/* keying step, sets x0 as a function of 4 inputs */
|
||||
#define STEP_SHA512_K(x0, x1, x9, xe) \
|
||||
{ \
|
||||
x0 += x9 + (ror64(x1, 1) ^ ror64(x1, 8) ^ (x1 >> 7)) + \
|
||||
(ror64(xe, 19) ^ ror64(xe, 61) ^ (xe >> 6)); \
|
||||
}
|
||||
|
||||
/* compression function (this one does *not* modify m[16]) */
|
||||
|
||||
void sha2_512_compress(void *v)
|
||||
{
|
||||
/* 4.2.3 SHA-384, SHA-512, SHA-512/224 and SHA-512/256 Constants */
|
||||
|
||||
const uint64_t ck[80] = {
|
||||
UINT64_C(0x428A2F98D728AE22), UINT64_C(0x7137449123EF65CD),
|
||||
UINT64_C(0xB5C0FBCFEC4D3B2F), UINT64_C(0xE9B5DBA58189DBBC),
|
||||
UINT64_C(0x3956C25BF348B538), UINT64_C(0x59F111F1B605D019),
|
||||
UINT64_C(0x923F82A4AF194F9B), UINT64_C(0xAB1C5ED5DA6D8118),
|
||||
UINT64_C(0xD807AA98A3030242), UINT64_C(0x12835B0145706FBE),
|
||||
UINT64_C(0x243185BE4EE4B28C), UINT64_C(0x550C7DC3D5FFB4E2),
|
||||
UINT64_C(0x72BE5D74F27B896F), UINT64_C(0x80DEB1FE3B1696B1),
|
||||
UINT64_C(0x9BDC06A725C71235), UINT64_C(0xC19BF174CF692694),
|
||||
UINT64_C(0xE49B69C19EF14AD2), UINT64_C(0xEFBE4786384F25E3),
|
||||
UINT64_C(0x0FC19DC68B8CD5B5), UINT64_C(0x240CA1CC77AC9C65),
|
||||
UINT64_C(0x2DE92C6F592B0275), UINT64_C(0x4A7484AA6EA6E483),
|
||||
UINT64_C(0x5CB0A9DCBD41FBD4), UINT64_C(0x76F988DA831153B5),
|
||||
UINT64_C(0x983E5152EE66DFAB), UINT64_C(0xA831C66D2DB43210),
|
||||
UINT64_C(0xB00327C898FB213F), UINT64_C(0xBF597FC7BEEF0EE4),
|
||||
UINT64_C(0xC6E00BF33DA88FC2), UINT64_C(0xD5A79147930AA725),
|
||||
UINT64_C(0x06CA6351E003826F), UINT64_C(0x142929670A0E6E70),
|
||||
UINT64_C(0x27B70A8546D22FFC), UINT64_C(0x2E1B21385C26C926),
|
||||
UINT64_C(0x4D2C6DFC5AC42AED), UINT64_C(0x53380D139D95B3DF),
|
||||
UINT64_C(0x650A73548BAF63DE), UINT64_C(0x766A0ABB3C77B2A8),
|
||||
UINT64_C(0x81C2C92E47EDAEE6), UINT64_C(0x92722C851482353B),
|
||||
UINT64_C(0xA2BFE8A14CF10364), UINT64_C(0xA81A664BBC423001),
|
||||
UINT64_C(0xC24B8B70D0F89791), UINT64_C(0xC76C51A30654BE30),
|
||||
UINT64_C(0xD192E819D6EF5218), UINT64_C(0xD69906245565A910),
|
||||
UINT64_C(0xF40E35855771202A), UINT64_C(0x106AA07032BBD1B8),
|
||||
UINT64_C(0x19A4C116B8D2D0C8), UINT64_C(0x1E376C085141AB53),
|
||||
UINT64_C(0x2748774CDF8EEB99), UINT64_C(0x34B0BCB5E19B48A8),
|
||||
UINT64_C(0x391C0CB3C5C95A63), UINT64_C(0x4ED8AA4AE3418ACB),
|
||||
UINT64_C(0x5B9CCA4F7763E373), UINT64_C(0x682E6FF3D6B2B8A3),
|
||||
UINT64_C(0x748F82EE5DEFB2FC), UINT64_C(0x78A5636F43172F60),
|
||||
UINT64_C(0x84C87814A1F0AB72), UINT64_C(0x8CC702081A6439EC),
|
||||
UINT64_C(0x90BEFFFA23631E28), UINT64_C(0xA4506CEBDE82BDE9),
|
||||
UINT64_C(0xBEF9A3F7B2C67915), UINT64_C(0xC67178F2E372532B),
|
||||
UINT64_C(0xCA273ECEEA26619C), UINT64_C(0xD186B8C721C0C207),
|
||||
UINT64_C(0xEADA7DD6CDE0EB1E), UINT64_C(0xF57D4F7FEE6ED178),
|
||||
UINT64_C(0x06F067AA72176FBA), UINT64_C(0x0A637DC5A2C898A6),
|
||||
UINT64_C(0x113F9804BEF90DAE), UINT64_C(0x1B710B35131C471B),
|
||||
UINT64_C(0x28DB77F523047D84), UINT64_C(0x32CAAB7B40C72493),
|
||||
UINT64_C(0x3C9EBE0A15C9BEBC), UINT64_C(0x431D67C49C100D4C),
|
||||
UINT64_C(0x4CC5D4BECB3E42B6), UINT64_C(0x597F299CFC657E2A),
|
||||
UINT64_C(0x5FCB6FAB3AD6FAEC), UINT64_C(0x6C44198C4A475817)};
|
||||
|
||||
uint64_t a, b, c, d, e, f, g, h;
|
||||
uint64_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, ma, mb, mc, md, me, mf;
|
||||
|
||||
uint64_t *sp = (uint64_t *)v;
|
||||
const uint64_t *mp = sp + 8;
|
||||
const uint64_t *kp = ck;
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
sha2_512_compress_count++; /* instrumentation */
|
||||
#endif
|
||||
|
||||
/* get state */
|
||||
a = sp[0] = rev8_be64(sp[0]);
|
||||
b = sp[1] = rev8_be64(sp[1]);
|
||||
c = sp[2] = rev8_be64(sp[2]);
|
||||
d = sp[3] = rev8_be64(sp[3]);
|
||||
e = sp[4] = rev8_be64(sp[4]);
|
||||
f = sp[5] = rev8_be64(sp[5]);
|
||||
g = sp[6] = rev8_be64(sp[6]);
|
||||
h = sp[7] = rev8_be64(sp[7]);
|
||||
|
||||
/* load and reverse bytes (if needed) */
|
||||
|
||||
m0 = rev8_be64(mp[0]);
|
||||
m1 = rev8_be64(mp[1]);
|
||||
m2 = rev8_be64(mp[2]);
|
||||
m3 = rev8_be64(mp[3]);
|
||||
m4 = rev8_be64(mp[4]);
|
||||
m5 = rev8_be64(mp[5]);
|
||||
m6 = rev8_be64(mp[6]);
|
||||
m7 = rev8_be64(mp[7]);
|
||||
m8 = rev8_be64(mp[8]);
|
||||
m9 = rev8_be64(mp[9]);
|
||||
ma = rev8_be64(mp[10]);
|
||||
mb = rev8_be64(mp[11]);
|
||||
mc = rev8_be64(mp[12]);
|
||||
md = rev8_be64(mp[13]);
|
||||
me = rev8_be64(mp[14]);
|
||||
mf = rev8_be64(mp[15]);
|
||||
|
||||
while (1)
|
||||
{
|
||||
/* main rounds */
|
||||
STEP_SHA512_R(a, b, c, d, e, f, g, h, m0, kp[0]);
|
||||
STEP_SHA512_R(h, a, b, c, d, e, f, g, m1, kp[1]);
|
||||
STEP_SHA512_R(g, h, a, b, c, d, e, f, m2, kp[2]);
|
||||
STEP_SHA512_R(f, g, h, a, b, c, d, e, m3, kp[3]);
|
||||
STEP_SHA512_R(e, f, g, h, a, b, c, d, m4, kp[4]);
|
||||
STEP_SHA512_R(d, e, f, g, h, a, b, c, m5, kp[5]);
|
||||
STEP_SHA512_R(c, d, e, f, g, h, a, b, m6, kp[6]);
|
||||
STEP_SHA512_R(b, c, d, e, f, g, h, a, m7, kp[7]);
|
||||
STEP_SHA512_R(a, b, c, d, e, f, g, h, m8, kp[8]);
|
||||
STEP_SHA512_R(h, a, b, c, d, e, f, g, m9, kp[9]);
|
||||
STEP_SHA512_R(g, h, a, b, c, d, e, f, ma, kp[10]);
|
||||
STEP_SHA512_R(f, g, h, a, b, c, d, e, mb, kp[11]);
|
||||
STEP_SHA512_R(e, f, g, h, a, b, c, d, mc, kp[12]);
|
||||
STEP_SHA512_R(d, e, f, g, h, a, b, c, md, kp[13]);
|
||||
STEP_SHA512_R(c, d, e, f, g, h, a, b, me, kp[14]);
|
||||
STEP_SHA512_R(b, c, d, e, f, g, h, a, mf, kp[15]);
|
||||
|
||||
if (kp == &ck[80 - 16])
|
||||
{
|
||||
break;
|
||||
}
|
||||
kp += 16;
|
||||
|
||||
STEP_SHA512_K(m0, m1, m9, me); /* key schedule */
|
||||
STEP_SHA512_K(m1, m2, ma, mf);
|
||||
STEP_SHA512_K(m2, m3, mb, m0);
|
||||
STEP_SHA512_K(m3, m4, mc, m1);
|
||||
STEP_SHA512_K(m4, m5, md, m2);
|
||||
STEP_SHA512_K(m5, m6, me, m3);
|
||||
STEP_SHA512_K(m6, m7, mf, m4);
|
||||
STEP_SHA512_K(m7, m8, m0, m5);
|
||||
STEP_SHA512_K(m8, m9, m1, m6);
|
||||
STEP_SHA512_K(m9, ma, m2, m7);
|
||||
STEP_SHA512_K(ma, mb, m3, m8);
|
||||
STEP_SHA512_K(mb, mc, m4, m9);
|
||||
STEP_SHA512_K(mc, md, m5, ma);
|
||||
STEP_SHA512_K(md, me, m6, mb);
|
||||
STEP_SHA512_K(me, mf, m7, mc);
|
||||
STEP_SHA512_K(mf, m0, m8, md);
|
||||
}
|
||||
|
||||
sp[0] = rev8_be64(sp[0] + a);
|
||||
sp[1] = rev8_be64(sp[1] + b);
|
||||
sp[2] = rev8_be64(sp[2] + c);
|
||||
sp[3] = rev8_be64(sp[3] + d);
|
||||
sp[4] = rev8_be64(sp[4] + e);
|
||||
sp[5] = rev8_be64(sp[5] + f);
|
||||
sp[6] = rev8_be64(sp[6] + g);
|
||||
sp[7] = rev8_be64(sp[7] + h);
|
||||
}
|
||||
|
||||
/* initialize */
|
||||
|
||||
static void sha2_512_init_h0(sha2_512_t *sha, const uint8_t *h0)
|
||||
{
|
||||
memcpy(sha->s, h0, 64);
|
||||
sha->i = 0;
|
||||
sha->len = 0;
|
||||
}
|
||||
|
||||
void sha2_512_init(sha2_512_t *sha)
|
||||
{
|
||||
/* SHA-512 initial values H0, Sect 5.3.5. */
|
||||
const uint8_t sha2_512_h0[64] = {
|
||||
0x6A, 0x09, 0xE6, 0x67, 0xF3, 0xBC, 0xC9, 0x08, 0xBB, 0x67, 0xAE,
|
||||
0x85, 0x84, 0xCA, 0xA7, 0x3B, 0x3C, 0x6E, 0xF3, 0x72, 0xFE, 0x94,
|
||||
0xF8, 0x2B, 0xA5, 0x4F, 0xF5, 0x3A, 0x5F, 0x1D, 0x36, 0xF1, 0x51,
|
||||
0x0E, 0x52, 0x7F, 0xAD, 0xE6, 0x82, 0xD1, 0x9B, 0x05, 0x68, 0x8C,
|
||||
0x2B, 0x3E, 0x6C, 0x1F, 0x1F, 0x83, 0xD9, 0xAB, 0xFB, 0x41, 0xBD,
|
||||
0x6B, 0x5B, 0xE0, 0xCD, 0x19, 0x13, 0x7E, 0x21, 0x79};
|
||||
|
||||
sha2_512_init_h0(sha, sha2_512_h0);
|
||||
}
|
||||
|
||||
void sha2_384_init(sha2_512_t *sha)
|
||||
{
|
||||
/* SHA-384 initial values H0, Sect 5.3.4. */
|
||||
const uint8_t sha2_384_h0[64] = {
|
||||
0xCB, 0xBB, 0x9D, 0x5D, 0xC1, 0x05, 0x9E, 0xD8, 0x62, 0x9A, 0x29,
|
||||
0x2A, 0x36, 0x7C, 0xD5, 0x07, 0x91, 0x59, 0x01, 0x5A, 0x30, 0x70,
|
||||
0xDD, 0x17, 0x15, 0x2F, 0xEC, 0xD8, 0xF7, 0x0E, 0x59, 0x39, 0x67,
|
||||
0x33, 0x26, 0x67, 0xFF, 0xC0, 0x0B, 0x31, 0x8E, 0xB4, 0x4A, 0x87,
|
||||
0x68, 0x58, 0x15, 0x11, 0xDB, 0x0C, 0x2E, 0x0D, 0x64, 0xF9, 0x8F,
|
||||
0xA7, 0x47, 0xB5, 0x48, 0x1D, 0xBE, 0xFA, 0x4F, 0xA4};
|
||||
|
||||
sha2_512_init_h0(sha, sha2_384_h0);
|
||||
}
|
||||
|
||||
void sha2_512_224_init(sha2_512_t *sha)
|
||||
{
|
||||
/* SHA-512/224 initial values H0, Sect 5.3.6.1. */
|
||||
const uint8_t sha2_512_224_h0[64] = {
|
||||
0x8C, 0x3D, 0x37, 0xC8, 0x19, 0x54, 0x4D, 0xA2, 0x73, 0xE1, 0x99,
|
||||
0x66, 0x89, 0xDC, 0xD4, 0xD6, 0x1D, 0xFA, 0xB7, 0xAE, 0x32, 0xFF,
|
||||
0x9C, 0x82, 0x67, 0x9D, 0xD5, 0x14, 0x58, 0x2F, 0x9F, 0xCF, 0x0F,
|
||||
0x6D, 0x2B, 0x69, 0x7B, 0xD4, 0x4D, 0xA8, 0x77, 0xE3, 0x6F, 0x73,
|
||||
0x04, 0xC4, 0x89, 0x42, 0x3F, 0x9D, 0x85, 0xA8, 0x6A, 0x1D, 0x36,
|
||||
0xC8, 0x11, 0x12, 0xE6, 0xAD, 0x91, 0xD6, 0x92, 0xA1};
|
||||
|
||||
sha2_512_init_h0(sha, sha2_512_224_h0);
|
||||
}
|
||||
|
||||
void sha2_512_256_init(sha2_512_t *sha)
|
||||
{
|
||||
/* SHA-512/256 initial values H0, Sect 5.3.6.2. */
|
||||
const uint8_t sha2_512_256_h0[64] = {
|
||||
0x22, 0x31, 0x21, 0x94, 0xFC, 0x2B, 0xF7, 0x2C, 0x9F, 0x55, 0x5F,
|
||||
0xA3, 0xC8, 0x4C, 0x64, 0xC2, 0x23, 0x93, 0xB8, 0x6B, 0x6F, 0x53,
|
||||
0xB1, 0x51, 0x96, 0x38, 0x77, 0x19, 0x59, 0x40, 0xEA, 0xBD, 0x96,
|
||||
0x28, 0x3E, 0xE2, 0xA8, 0x8E, 0xFF, 0xE3, 0xBE, 0x5E, 0x1E, 0x25,
|
||||
0x53, 0x86, 0x39, 0x92, 0x2B, 0x01, 0x99, 0xFC, 0x2C, 0x85, 0xB8,
|
||||
0xAA, 0x0E, 0xB7, 0x2D, 0xDC, 0x81, 0xC5, 0x2C, 0xA2};
|
||||
|
||||
sha2_512_init_h0(sha, sha2_512_256_h0);
|
||||
}
|
||||
|
||||
void sha2_512_copy(sha2_512_t *dst, const sha2_512_t *src)
|
||||
{
|
||||
dst->i = src->i;
|
||||
dst->len = src->len;
|
||||
memcpy(dst->s, src->s, 64 + src->i);
|
||||
}
|
||||
|
||||
/* take message input */
|
||||
|
||||
void sha2_512_update(sha2_512_t *sha, const uint8_t *m, size_t m_sz)
|
||||
{
|
||||
size_t l;
|
||||
uint8_t *mp = (uint8_t *)&sha->s[8];
|
||||
|
||||
sha->len += m_sz;
|
||||
l = 128 - sha->i;
|
||||
|
||||
if (m_sz < l)
|
||||
{
|
||||
memcpy(mp + sha->i, m, m_sz);
|
||||
sha->i += m_sz;
|
||||
return;
|
||||
}
|
||||
if (sha->i > 0)
|
||||
{
|
||||
memcpy(mp + sha->i, m, l);
|
||||
sha2_512_compress(sha->s);
|
||||
m_sz -= l;
|
||||
m += l;
|
||||
sha->i = 0;
|
||||
}
|
||||
while (m_sz >= 128)
|
||||
{
|
||||
memcpy(mp, m, 128);
|
||||
sha2_512_compress(sha->s);
|
||||
m_sz -= 128;
|
||||
m += 128;
|
||||
}
|
||||
memcpy(mp, m, m_sz);
|
||||
sha->i = m_sz;
|
||||
}
|
||||
|
||||
/* perform final padding */
|
||||
|
||||
void sha2_512_final_pad(sha2_512_t *sha)
|
||||
{
|
||||
uint8_t *mp = (uint8_t *)&sha->s[8];
|
||||
uint64_t x;
|
||||
size_t i;
|
||||
|
||||
i = sha->i; /* last data block */
|
||||
mp[i++] = 0x80;
|
||||
if (i > 112)
|
||||
{
|
||||
memset(mp + i, 0x00, 128 - i);
|
||||
sha2_512_compress(sha->s);
|
||||
i = 0;
|
||||
}
|
||||
memset(mp + i, 0x00, 128 - i); /* clear rest */
|
||||
|
||||
x = ((uint64_t)sha->len) << 3; /* process length */
|
||||
i = 128;
|
||||
while (x > 0)
|
||||
{
|
||||
mp[--i] = x & 0xFF;
|
||||
x >>= 8;
|
||||
}
|
||||
}
|
||||
|
||||
/* produce h_sz byte hash */
|
||||
|
||||
void sha2_512_final_len(sha2_512_t *sha, uint8_t *h, size_t h_sz)
|
||||
{
|
||||
sha2_512_final_pad(sha);
|
||||
sha2_512_compress(sha->s);
|
||||
memcpy(h, sha->s, h_sz);
|
||||
}
|
||||
|
||||
/* public single-call interfaces */
|
||||
|
||||
void sha2_512(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_512_t sha;
|
||||
|
||||
sha2_512_init(&sha);
|
||||
sha2_512_update(&sha, m, m_sz);
|
||||
sha2_512_final(&sha, h);
|
||||
}
|
||||
|
||||
void sha2_384(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_384_t sha;
|
||||
|
||||
sha2_384_init(&sha);
|
||||
sha2_512_update(&sha, m, m_sz);
|
||||
sha2_512_final_len(&sha, h, 48);
|
||||
}
|
||||
|
||||
void sha2_512_224(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_512_t sha;
|
||||
|
||||
sha2_512_224_init(&sha);
|
||||
sha2_512_update(&sha, m, m_sz);
|
||||
sha2_512_final_len(&sha, h, 28);
|
||||
}
|
||||
|
||||
void sha2_512_256(uint8_t *h, const void *m, size_t m_sz)
|
||||
{
|
||||
sha2_512_t sha;
|
||||
|
||||
sha2_512_256_init(&sha);
|
||||
sha2_512_update(&sha, m, m_sz);
|
||||
sha2_512_final_len(&sha, h, 32);
|
||||
}
|
||||
97
src/sig/slh_dsa/slh_dsa_c/sha2_api.h
Normal file
97
src/sig/slh_dsa/slh_dsa_c/sha2_api.h
Normal file
@ -0,0 +1,97 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 180-4 (SHA-2) -- traditional "MD" type hash API interface. */
|
||||
|
||||
#ifndef _SHA2_API_H_
|
||||
#define _SHA2_API_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* === Single-call hash wrappers === */
|
||||
|
||||
/* SHA2-224: Compute 28-byte hash to "md" from "m" which has "m_sz" bytes. */
|
||||
void sha2_224(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* SHA2-256: Compute 32-byte hash to "md" from "m" which has "m_sz" bytes. */
|
||||
void sha2_256(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* SHA2-384: Compute 48-byte hash to "md" from "m" which has "m_sz" bytes. */
|
||||
void sha2_384(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* SHA2-512: Compute 64-byte hash to "md" from "m" which has "m_sz" bytes. */
|
||||
void sha2_512(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* SHA2-512/224: Compute 64-byte hash to "md" from "m" which has "m_sz" */
|
||||
/* bytes. */
|
||||
void sha2_512_224(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* SHA2-512/256: Compute 64-byte hash to "md" from "m" which has "m_sz" */
|
||||
/* bytes. */
|
||||
void sha2_512_256(uint8_t *md, const void *m, size_t m_sz);
|
||||
|
||||
/* === incremental interface === */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint32_t s[8 + 24];
|
||||
size_t i, len;
|
||||
} sha2_256_t;
|
||||
|
||||
typedef sha2_256_t sha2_224_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint64_t s[8 + 24];
|
||||
size_t i, len;
|
||||
} sha2_512_t;
|
||||
|
||||
typedef sha2_512_t sha2_384_t;
|
||||
|
||||
/* shaNNN_init(var): Initialize context for hashing. */
|
||||
void sha2_256_init(sha2_256_t *sha);
|
||||
void sha2_224_init(sha2_256_t *sha);
|
||||
void sha2_512_init(sha2_512_t *sha);
|
||||
void sha2_384_init(sha2_512_t *sha);
|
||||
void sha2_512_224_init(sha2_512_t *sha);
|
||||
void sha2_512_256_init(sha2_512_t *sha);
|
||||
|
||||
/* shaNNN_update(var, m, m_sz): Include "m" of "m_sz" bytes in hash. */
|
||||
void sha2_256_update(sha2_256_t *sha, const uint8_t *m, size_t m_sz);
|
||||
#define sha2_224_update(sha, m, m_sz) sha2_256_update(sha, m, m_sz)
|
||||
void sha2_512_update(sha2_512_t *sha, const uint8_t *m, size_t m_sz);
|
||||
#define sha2_384_update(sha, m, m_sz) sha2_512_update(sha, m, m_sz)
|
||||
|
||||
/* shaNNN_final(var, h): Finalize hash to "h", and clear the state. */
|
||||
void sha2_256_final_len(sha2_256_t *sha, uint8_t *h, size_t hlen);
|
||||
#define sha2_256_final(sha, h) sha2_256_final_len(sha, h, 32)
|
||||
#define sha2_224_final(sha, h) sha2_256_final_len(sha, h, 28)
|
||||
void sha2_512_final_len(sha2_512_t *sha, uint8_t *h, size_t hlen);
|
||||
#define sha2_512_final(sha, h) sha2_512_final_len(sha, h, 64)
|
||||
#define sha2_384_final(sha, h) sha2_512_final_len(sha, h, 48)
|
||||
|
||||
/* final padding */
|
||||
void sha2_256_final_pad(sha2_256_t *sha);
|
||||
void sha2_512_final_pad(sha2_512_t *sha);
|
||||
|
||||
/* copy state */
|
||||
void sha2_256_copy(sha2_256_t *dst, const sha2_256_t *src);
|
||||
void sha2_512_copy(sha2_512_t *dst, const sha2_512_t *src);
|
||||
|
||||
/* compression functions */
|
||||
void sha2_256_compress(void *v);
|
||||
void sha2_512_compress(void *v);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SHA2_API_H_ */
|
||||
111
src/sig/slh_dsa/slh_dsa_c/sha3_api.c
Normal file
111
src/sig/slh_dsa/slh_dsa_c/sha3_api.c
Normal file
@ -0,0 +1,111 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 202: SHA-3 hash and SHAKE eXtensible Output Functions (XOF) */
|
||||
|
||||
#include "sha3_api.h"
|
||||
|
||||
/* These functions have not been optimized for performance. */
|
||||
/* initialize the context for SHA3 */
|
||||
|
||||
void sha3_init(sha3_var_t *c, size_t md_sz)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < 25; i++)
|
||||
{
|
||||
c->st.d[i] = 0;
|
||||
}
|
||||
c->md_sz = md_sz; /* in SHAKE; if 0, padding done */
|
||||
c->r_sz = 200 - 2 * md_sz;
|
||||
c->pt = 0;
|
||||
}
|
||||
|
||||
/* update state with more data */
|
||||
|
||||
void sha3_update(sha3_var_t *c, const void *data, size_t len)
|
||||
{
|
||||
size_t i, j;
|
||||
|
||||
j = c->pt;
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
c->st.b[j++] ^= ((const uint8_t *)data)[i];
|
||||
if (j >= c->r_sz)
|
||||
{
|
||||
keccak_f1600(c->st.d);
|
||||
j = 0;
|
||||
}
|
||||
}
|
||||
c->pt = j;
|
||||
}
|
||||
|
||||
/* finalize and output a hash */
|
||||
|
||||
void sha3_final(sha3_var_t *c, uint8_t *md)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
c->st.b[c->pt] ^= 0x06;
|
||||
c->st.b[c->r_sz - 1] ^= 0x80;
|
||||
keccak_f1600(c->st.d);
|
||||
|
||||
for (i = 0; i < c->md_sz; i++)
|
||||
{
|
||||
md[i] = c->st.b[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* compute a SHA-3 hash "md" of "md_sz" bytes from data in "in" */
|
||||
|
||||
void sha3(uint8_t *md, size_t md_sz, const void *in, size_t in_sz)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
|
||||
sha3_init(&sha3, md_sz);
|
||||
sha3_update(&sha3, in, in_sz);
|
||||
sha3_final(&sha3, md);
|
||||
}
|
||||
|
||||
/* SHAKE128 and SHAKE256 extensible-output functionality */
|
||||
/* squeeze output */
|
||||
|
||||
void shake_out(sha3_var_t *c, uint8_t *out, size_t out_sz)
|
||||
{
|
||||
size_t i, j;
|
||||
|
||||
/* add padding on the first call */
|
||||
if (c->md_sz != 0)
|
||||
{
|
||||
c->st.b[c->pt] ^= 0x1F;
|
||||
c->st.b[c->r_sz - 1] ^= 0x80;
|
||||
keccak_f1600(c->st.d);
|
||||
c->pt = 0;
|
||||
c->md_sz = 0;
|
||||
}
|
||||
|
||||
j = c->pt;
|
||||
for (i = 0; i < out_sz; i++)
|
||||
{
|
||||
if (j >= c->r_sz)
|
||||
{
|
||||
keccak_f1600(c->st.d);
|
||||
j = 0;
|
||||
}
|
||||
out[i] = c->st.b[j++];
|
||||
}
|
||||
c->pt = j;
|
||||
}
|
||||
|
||||
/* compute a SHAKE hash "md" of "md_sz" bytes from data in "in" */
|
||||
|
||||
void shake(uint8_t *md, size_t md_sz, const void *in, size_t in_sz, size_t r_sz)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
|
||||
sha3_init(&sha3, r_sz);
|
||||
sha3_update(&sha3, in, in_sz);
|
||||
shake_out(&sha3, md, md_sz);
|
||||
}
|
||||
59
src/sig/slh_dsa/slh_dsa_c/sha3_api.h
Normal file
59
src/sig/slh_dsa/slh_dsa_c/sha3_api.h
Normal file
@ -0,0 +1,59 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 202: SHA-3 hash and SHAKE eXtensible Output Functions (XOF) */
|
||||
|
||||
#ifndef _SHA3_API_H_
|
||||
#define _SHA3_API_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
typedef struct
|
||||
{ /* state context */
|
||||
union
|
||||
{
|
||||
uint8_t b[200]; /* 8-bit bytes */
|
||||
uint64_t d[25]; /* 64-bit words */
|
||||
} st;
|
||||
size_t pt, r_sz, md_sz;
|
||||
} sha3_var_t;
|
||||
|
||||
/* compute a hash "md" of "md_sz" bytes from data in "in" */
|
||||
void sha3(uint8_t *md, size_t md_sz, const void *in, size_t in_sz);
|
||||
|
||||
/* incremental interfece */
|
||||
void sha3_init(sha3_var_t *c,
|
||||
size_t md_sz); /* md_sz = hash output in bytes */
|
||||
void sha3_update(sha3_var_t *c, const void *data, size_t data_sz);
|
||||
void sha3_final(sha3_var_t *c, uint8_t *md); /* digest goes to md */
|
||||
|
||||
/* SHAKE128 and SHAKE256 extensible-output functions */
|
||||
#define shake128_init(c) sha3_init(c, 16)
|
||||
#define shake256_init(c) sha3_init(c, 32)
|
||||
#define shake_update sha3_update
|
||||
|
||||
/* compute a hash "md" of "md_sz" bytes from data in "in" */
|
||||
void shake(uint8_t *md, size_t md_sz, const void *in, size_t in_sz,
|
||||
size_t r_sz);
|
||||
#define shake128(md, md_sz, in, in_sz) shake(md, md_sz, in, in_sz, 16)
|
||||
#define shake256(md, md_sz, in, in_sz) shake(md, md_sz, in, in_sz, 32)
|
||||
|
||||
/* squeeze output (can call repeat) */
|
||||
void shake_out(sha3_var_t *c, uint8_t *out, size_t out_sz);
|
||||
|
||||
/* core permutation */
|
||||
void keccak_f1600(uint64_t x[25]);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SHA3_API_H_ */
|
||||
155
src/sig/slh_dsa/slh_dsa_c/sha3_f1600.c
Normal file
155
src/sig/slh_dsa/slh_dsa_c/sha3_f1600.c
Normal file
@ -0,0 +1,155 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 202 Keccak permutation implementation for a 64-bit target. */
|
||||
|
||||
#include "plat_local.h"
|
||||
#include "sha3_api.h"
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
uint64_t keccak_f1600_count = 0; /* instrumentation */
|
||||
#endif
|
||||
|
||||
/* forward permutation */
|
||||
|
||||
void keccak_f1600(uint64_t x[25])
|
||||
{
|
||||
/* round constants */
|
||||
static const uint64_t keccak_rc[24] = {
|
||||
UINT64_C(0x0000000000000001), UINT64_C(0x0000000000008082),
|
||||
UINT64_C(0x800000000000808A), UINT64_C(0x8000000080008000),
|
||||
UINT64_C(0x000000000000808B), UINT64_C(0x0000000080000001),
|
||||
UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008009),
|
||||
UINT64_C(0x000000000000008A), UINT64_C(0x0000000000000088),
|
||||
UINT64_C(0x0000000080008009), UINT64_C(0x000000008000000A),
|
||||
UINT64_C(0x000000008000808B), UINT64_C(0x800000000000008B),
|
||||
UINT64_C(0x8000000000008089), UINT64_C(0x8000000000008003),
|
||||
UINT64_C(0x8000000000008002), UINT64_C(0x8000000000000080),
|
||||
UINT64_C(0x000000000000800A), UINT64_C(0x800000008000000A),
|
||||
UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008080),
|
||||
UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008008)};
|
||||
|
||||
int i;
|
||||
uint64_t t, y0, y1, y2, y3, y4;
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
keccak_f1600_count++; /* instrumentation */
|
||||
#endif
|
||||
|
||||
/* iteration */
|
||||
|
||||
for (i = 0; i < 24; i++)
|
||||
{
|
||||
/* Theta */
|
||||
|
||||
y4 = x[4] ^ x[9] ^ x[14] ^ x[19] ^ x[24];
|
||||
y1 = x[1] ^ x[6] ^ x[11] ^ x[16] ^ x[21];
|
||||
y3 = x[3] ^ x[8] ^ x[13] ^ x[18] ^ x[23];
|
||||
y0 = x[0] ^ x[5] ^ x[10] ^ x[15] ^ x[20];
|
||||
y2 = x[2] ^ x[7] ^ x[12] ^ x[17] ^ x[22];
|
||||
|
||||
t = ror64(y4, 63);
|
||||
y4 ^= ror64(y1, 63);
|
||||
y1 ^= ror64(y3, 63);
|
||||
y3 ^= ror64(y0, 63);
|
||||
y0 ^= ror64(y2, 63);
|
||||
y2 ^= t;
|
||||
|
||||
x[0] ^= y4;
|
||||
x[1] ^= y0;
|
||||
x[2] ^= y1;
|
||||
x[3] ^= y2;
|
||||
x[4] ^= y3;
|
||||
x[5] ^= y4;
|
||||
x[6] ^= y0;
|
||||
x[7] ^= y1;
|
||||
x[8] ^= y2;
|
||||
x[9] ^= y3;
|
||||
x[10] ^= y4;
|
||||
x[11] ^= y0;
|
||||
x[12] ^= y1;
|
||||
x[13] ^= y2;
|
||||
x[14] ^= y3;
|
||||
x[15] ^= y4;
|
||||
x[16] ^= y0;
|
||||
x[17] ^= y1;
|
||||
x[18] ^= y2;
|
||||
x[19] ^= y3;
|
||||
x[20] ^= y4;
|
||||
x[21] ^= y0;
|
||||
x[22] ^= y1;
|
||||
x[23] ^= y2;
|
||||
x[24] ^= y3;
|
||||
|
||||
/* Rho Pi */
|
||||
|
||||
t = ror64(x[1], 63);
|
||||
x[1] = ror64(x[6], 20);
|
||||
x[6] = ror64(x[9], 44);
|
||||
x[9] = ror64(x[22], 3);
|
||||
x[22] = ror64(x[14], 25);
|
||||
x[14] = ror64(x[20], 46);
|
||||
x[20] = ror64(x[2], 2);
|
||||
x[2] = ror64(x[12], 21);
|
||||
x[12] = ror64(x[13], 39);
|
||||
x[13] = ror64(x[19], 56);
|
||||
x[19] = ror64(x[23], 8);
|
||||
x[23] = ror64(x[15], 23);
|
||||
x[15] = ror64(x[4], 37);
|
||||
x[4] = ror64(x[24], 50);
|
||||
x[24] = ror64(x[21], 62);
|
||||
x[21] = ror64(x[8], 9);
|
||||
x[8] = ror64(x[16], 19);
|
||||
x[16] = ror64(x[5], 28);
|
||||
x[5] = ror64(x[3], 36);
|
||||
x[3] = ror64(x[18], 43);
|
||||
x[18] = ror64(x[17], 49);
|
||||
x[17] = ror64(x[11], 54);
|
||||
x[11] = ror64(x[7], 58);
|
||||
x[7] = ror64(x[10], 61);
|
||||
x[10] = t;
|
||||
|
||||
/* Chi */
|
||||
|
||||
t = x[4] & ~x[3];
|
||||
x[4] ^= x[1] & ~x[0];
|
||||
x[1] ^= x[3] & ~x[2];
|
||||
x[3] ^= x[0] & ~x[4];
|
||||
x[0] ^= x[2] & ~x[1];
|
||||
x[2] ^= t;
|
||||
|
||||
t = x[9] & ~x[8];
|
||||
x[9] ^= x[6] & ~x[5];
|
||||
x[6] ^= x[8] & ~x[7];
|
||||
x[8] ^= x[5] & ~x[9];
|
||||
x[5] ^= x[7] & ~x[6];
|
||||
x[7] ^= t;
|
||||
|
||||
t = x[14] & ~x[13];
|
||||
x[14] ^= x[11] & ~x[10];
|
||||
x[11] ^= x[13] & ~x[12];
|
||||
x[13] ^= x[10] & ~x[14];
|
||||
x[10] ^= x[12] & ~x[11];
|
||||
x[12] ^= t;
|
||||
|
||||
t = x[19] & ~x[18];
|
||||
x[19] ^= x[16] & ~x[15];
|
||||
x[16] ^= x[18] & ~x[17];
|
||||
x[18] ^= x[15] & ~x[19];
|
||||
x[15] ^= x[17] & ~x[16];
|
||||
x[17] ^= t;
|
||||
|
||||
t = x[24] & ~x[23];
|
||||
x[24] ^= x[21] & ~x[20];
|
||||
x[21] ^= x[23] & ~x[22];
|
||||
x[23] ^= x[20] & ~x[24];
|
||||
x[20] ^= x[22] & ~x[21];
|
||||
x[22] ^= t;
|
||||
|
||||
/* Iota */
|
||||
|
||||
x[0] = x[0] ^ keccak_rc[i];
|
||||
}
|
||||
}
|
||||
175
src/sig/slh_dsa/slh_dsa_c/slh_adrs.h
Normal file
175
src/sig/slh_dsa/slh_dsa_c/slh_adrs.h
Normal file
@ -0,0 +1,175 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Internal ADRS manipulation functions (FIPS 205 Section 4.3) */
|
||||
|
||||
#ifndef _SLH_ADRS_H_
|
||||
#define _SLH_ADRS_H_
|
||||
|
||||
#include <string.h>
|
||||
#include "slh_param.h"
|
||||
#include "slh_var.h"
|
||||
|
||||
/* ADRS type constants */
|
||||
|
||||
#define ADRS_WOTS_HASH 0
|
||||
#define ADRS_WOTS_PK 1
|
||||
#define ADRS_TREE 2
|
||||
#define ADRS_FORS_TREE 3
|
||||
#define ADRS_FORS_ROOTS 4
|
||||
#define ADRS_WOTS_PRF 5
|
||||
#define ADRS_FORS_PRF 6
|
||||
|
||||
/* Algorithm 1: toInt(x, n) */
|
||||
|
||||
static inline uint64_t slh_toint(const uint8_t *x, unsigned n)
|
||||
{
|
||||
unsigned i;
|
||||
uint64_t t;
|
||||
|
||||
if (n == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
t = (uint64_t)x[0];
|
||||
for (i = 1; i < n; i++)
|
||||
{
|
||||
t <<= 8;
|
||||
t += (uint64_t)x[i];
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
/* Algorithm 2: toByte(x, n) */
|
||||
|
||||
static inline void slh_tobyte(uint8_t *x, uint64_t t, unsigned n)
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
if (n == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
for (i = n - 1; i > 0; i--)
|
||||
{
|
||||
x[i] = (uint8_t)(t & 0xFF);
|
||||
t >>= 8;
|
||||
}
|
||||
x[0] = (uint8_t)t;
|
||||
}
|
||||
|
||||
/* === Clear / initialize */
|
||||
static inline void adrs_zero(slh_var_t *var)
|
||||
{
|
||||
var->adrs->u32[0] = 0;
|
||||
var->adrs->u32[1] = 0;
|
||||
var->adrs->u32[2] = 0;
|
||||
var->adrs->u32[3] = 0;
|
||||
var->adrs->u32[4] = 0;
|
||||
var->adrs->u32[5] = 0;
|
||||
var->adrs->u32[6] = 0;
|
||||
var->adrs->u32[7] = 0;
|
||||
}
|
||||
|
||||
/* === Set layer address. */
|
||||
static inline void adrs_set_layer_address(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[0] = rev8_be32(x);
|
||||
}
|
||||
|
||||
/* === Set tree addresss. */
|
||||
static inline void adrs_set_tree_address(slh_var_t *var, uint64_t x)
|
||||
{
|
||||
/* bytes a[4:8] of tree address are always zero */
|
||||
var->adrs->u32[2] = rev8_be32(x >> 32);
|
||||
var->adrs->u32[3] = rev8_be32(x & 0xFFFFFFFF);
|
||||
}
|
||||
|
||||
/* === Set key pair Address. */
|
||||
static inline void adrs_set_key_pair_address(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[5] = rev8_be32(x);
|
||||
}
|
||||
|
||||
/* === Get key pair Address. */
|
||||
static inline uint32_t adrs_get_key_pair_address(const slh_var_t *var)
|
||||
{
|
||||
return rev8_be32(var->adrs->u32[5]);
|
||||
}
|
||||
|
||||
/* === Set FORS tree height. */
|
||||
static inline void adrs_set_tree_height(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[6] = rev8_be32(x);
|
||||
}
|
||||
|
||||
/* === Set WOTS+ chain address. */
|
||||
static inline void adrs_set_chain_address(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[6] = rev8_be32(x);
|
||||
}
|
||||
|
||||
/* === Set FORS tree index. */
|
||||
static inline void adrs_set_tree_index(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[7] = rev8_be32(x);
|
||||
}
|
||||
|
||||
/* === Get FORS tree index. */
|
||||
static inline uint32_t adrs_get_tree_index(const slh_var_t *var)
|
||||
{
|
||||
return rev8_be32(var->adrs->u32[7]);
|
||||
}
|
||||
|
||||
/* === Set WOTS+ hash address. */
|
||||
static inline void adrs_set_hash_address(slh_var_t *var, uint32_t x)
|
||||
{
|
||||
var->adrs->u32[7] = rev8_be32(x);
|
||||
}
|
||||
|
||||
static inline void adrs_set_type(slh_var_t *var, uint32_t y)
|
||||
{
|
||||
var->adrs->u32[4] = rev8_be32(y);
|
||||
}
|
||||
|
||||
static inline uint32_t adrs_get_type(slh_var_t *var)
|
||||
{
|
||||
return rev8_be32(var->adrs->u32[4]);
|
||||
}
|
||||
|
||||
/* === "Function ADRS.setTypeAndClear(Y) for addresses sets the type */
|
||||
/* of the ADRS to Y and sets the final 12 bytes of the ADRS to zero." */
|
||||
static inline void adrs_set_type_and_clear(slh_var_t *var, uint32_t y)
|
||||
{
|
||||
var->adrs->u32[4] = rev8_be32(y);
|
||||
var->adrs->u32[5] = 0;
|
||||
var->adrs->u32[6] = 0;
|
||||
var->adrs->u32[7] = 0;
|
||||
}
|
||||
|
||||
static inline void adrs_set_type_and_clear_not_kp(slh_var_t *var, uint32_t y)
|
||||
{
|
||||
var->adrs->u32[4] = rev8_be32(y);
|
||||
var->adrs->u32[6] = 0;
|
||||
var->adrs->u32[7] = 0;
|
||||
}
|
||||
|
||||
/* === Compressed 22-byte address ADRSc used with SHA-2. */
|
||||
static inline void adrsc_22(const slh_var_t *var, uint8_t *ac)
|
||||
{
|
||||
int i;
|
||||
ac[0] = var->adrs->u8[3];
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
ac[i + 1] = var->adrs->u8[i + 8];
|
||||
}
|
||||
for (i = 0; i < 13; i++)
|
||||
{
|
||||
ac[i + 9] = var->adrs->u8[i + 19];
|
||||
}
|
||||
}
|
||||
|
||||
/* _SLH_ADRS_H_ */
|
||||
#endif
|
||||
717
src/sig/slh_dsa/slh_dsa_c/slh_dsa.c
Normal file
717
src/sig/slh_dsa/slh_dsa_c/slh_dsa.c
Normal file
@ -0,0 +1,717 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 205 Stateless Hash-Based Digital Signature Standard */
|
||||
|
||||
#include "slh_dsa.h"
|
||||
#include "slh_adrs.h"
|
||||
#include "slh_var.h"
|
||||
|
||||
/* === Internal */
|
||||
|
||||
/* helper functions to compute "len = len1 + len2" */
|
||||
|
||||
static inline uint32_t get_len1(const slh_param_t *prm)
|
||||
{
|
||||
return ((8 * prm->n + (prm->lg_w - 1)) / prm->lg_w);
|
||||
}
|
||||
|
||||
/* === Computes len2 (Equation 5.3). */
|
||||
/* Algorithm 1: gen_len2(n, lg_w) */
|
||||
|
||||
static inline uint32_t gen_len2(const slh_param_t *prm)
|
||||
{
|
||||
uint32_t len2, cap, maxs;
|
||||
|
||||
/* "When lg_w = 4 and 9 <= n <= 136, the value of len2 will be 3." */
|
||||
if (prm->lg_w == 4 && prm->n >= 9 && prm->n <= 136)
|
||||
{
|
||||
return 3;
|
||||
}
|
||||
|
||||
maxs = get_len1(prm) * ((1 << prm->lg_w) - 1);
|
||||
len2 = 1;
|
||||
cap = 1 << prm->lg_w;
|
||||
while (cap < maxs)
|
||||
{
|
||||
len2++;
|
||||
cap <<= prm->lg_w;
|
||||
}
|
||||
return len2;
|
||||
}
|
||||
|
||||
static inline uint32_t get_len(const slh_param_t *prm)
|
||||
{
|
||||
return get_len1(prm) + gen_len2(prm);
|
||||
}
|
||||
|
||||
/* Return signature size in bytes for parameter set *prm. */
|
||||
size_t slh_sig_sz(const slh_param_t *prm)
|
||||
{
|
||||
return (1 + prm->k * (1 + prm->a) + prm->h + prm->d * get_len(prm)) * prm->n;
|
||||
}
|
||||
|
||||
/* === Compute the base 2**b representation of X. */
|
||||
/* Algorithm 4: base_2b(X, b, out_len) */
|
||||
|
||||
static inline size_t base_2b(uint32_t *v, const uint8_t *x, uint32_t b,
|
||||
size_t v_len)
|
||||
{
|
||||
size_t i, j;
|
||||
uint32_t l, t, m;
|
||||
|
||||
j = 0;
|
||||
l = 0;
|
||||
t = 0;
|
||||
m = (1 << b) - 1;
|
||||
for (i = 0; i < v_len; i++)
|
||||
{
|
||||
while (l < b)
|
||||
{
|
||||
t = (t << 8) + ((uint32_t) x[j++]);
|
||||
l += 8;
|
||||
}
|
||||
l -= b;
|
||||
v[i] = (t >> l) & m;
|
||||
}
|
||||
return j;
|
||||
}
|
||||
|
||||
/* === Chaining function used in WOTS+ */
|
||||
/* Algorithm 5: chain(X, i, s, PK.seed, ADRS) */
|
||||
/* (see prm->chain) */
|
||||
|
||||
/* === Generate a WOTS+ public key. */
|
||||
/* Algorithm 6: wots_PKgen(SK.seed, PK.seed, ADRS) */
|
||||
/* (see xmms_node) */
|
||||
|
||||
/* === Generate a WOTS+ signature on an n-byte message. */
|
||||
/* Algorithm 7: wots_sign(M, SK.seed, PK.seed, ADRS) */
|
||||
|
||||
/* (wots_csum is a shared helper function for algorithms 7 and 8) */
|
||||
static void wots_csum(uint32_t *vm, const uint8_t *m, const slh_param_t *prm)
|
||||
{
|
||||
uint32_t csum, i, t;
|
||||
uint32_t len1, len2;
|
||||
uint8_t buf[4];
|
||||
|
||||
len1 = get_len1(prm);
|
||||
len2 = gen_len2(prm);
|
||||
|
||||
base_2b(vm, m, prm->lg_w, len1);
|
||||
|
||||
csum = 0;
|
||||
t = (1 << prm->lg_w) - 1;
|
||||
for (i = 0; i < len1; i++)
|
||||
{
|
||||
csum += t - vm[i];
|
||||
}
|
||||
csum <<= (8 - ((len2 * prm->lg_w) & 7)) & 7;
|
||||
|
||||
t = (len2 * prm->lg_w + 7) / 8;
|
||||
memset(buf, 0, sizeof(buf));
|
||||
slh_tobyte(buf, csum, t);
|
||||
|
||||
base_2b(&vm[len1], buf, prm->lg_w, len2);
|
||||
}
|
||||
|
||||
static size_t wots_sign(slh_var_t *var, uint8_t *sig, const uint8_t *m)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t i, len;
|
||||
uint32_t vm[SLH_MAX_LEN];
|
||||
size_t n = prm->n;
|
||||
|
||||
len = get_len(prm);
|
||||
wots_csum(vm, m, prm);
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
adrs_set_chain_address(var, i);
|
||||
prm->wots_chain(var, sig, vm[i]);
|
||||
sig += n;
|
||||
}
|
||||
return n * len;
|
||||
}
|
||||
|
||||
/* === Compute a WOTS+ public key from a message and its signature. */
|
||||
/* Algorithm 8: wots_PKFromSig(sig, M, PK.seed, ADRS) */
|
||||
|
||||
static void wots_pk_from_sig(slh_var_t *var, uint8_t *pk, const uint8_t *sig,
|
||||
const uint8_t *m)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
size_t n = prm->n;
|
||||
uint32_t i, t, len;
|
||||
uint32_t vm[SLH_MAX_LEN];
|
||||
uint8_t tmp[SLH_MAX_LEN * SLH_MAX_N];
|
||||
size_t tmp_sz;
|
||||
|
||||
wots_csum(vm, m, prm);
|
||||
|
||||
len = get_len(prm);
|
||||
t = (1 << prm->lg_w) - 1;
|
||||
tmp_sz = 0;
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
adrs_set_chain_address(var, i);
|
||||
prm->chain(var, tmp + tmp_sz, sig + tmp_sz, vm[i], t - vm[i]);
|
||||
tmp_sz += n;
|
||||
}
|
||||
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_WOTS_PK);
|
||||
prm->h_t(var, pk, tmp, tmp_sz);
|
||||
}
|
||||
|
||||
/* === Compute the root of a Merkle subtree of WOTS+ public keys. */
|
||||
/* Algorithm 9: xmss_node(SK.seed, i, z, PK.seed, ADRS) */
|
||||
|
||||
static void xmss_node(slh_var_t *var, uint8_t *node, uint32_t i, uint32_t z)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t j, k, w1;
|
||||
int p;
|
||||
uint8_t *h0, h[SLH_MAX_HP][SLH_MAX_N];
|
||||
uint8_t tmp[SLH_MAX_LEN * SLH_MAX_N];
|
||||
uint8_t *sk;
|
||||
size_t n = prm->n;
|
||||
size_t len = get_len(prm);
|
||||
|
||||
p = -1;
|
||||
i <<= z;
|
||||
w1 = (1 << prm->lg_w) - 1;
|
||||
for (j = 0; j < (1u << z); j++)
|
||||
{
|
||||
adrs_set_key_pair_address(var, i);
|
||||
|
||||
/* === Generate a WOTS+ public key. */
|
||||
/* Algorithm 6: wots_PKgen(SK.seed, PK.seed, ADRS) */
|
||||
sk = tmp;
|
||||
for (k = 0; k < len; k++)
|
||||
{
|
||||
adrs_set_chain_address(var, k);
|
||||
prm->wots_chain(var, sk, w1);
|
||||
sk += n;
|
||||
}
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_WOTS_PK);
|
||||
h0 = p >= 0 ? h[p] : node;
|
||||
p++;
|
||||
prm->h_t(var, h0, tmp, len * n);
|
||||
|
||||
/* this xmss_node() implementation is non-recursive */
|
||||
for (k = 0; (j >> k) & 1; k++)
|
||||
{
|
||||
adrs_set_type_and_clear(var, ADRS_TREE);
|
||||
adrs_set_tree_height(var, k + 1);
|
||||
adrs_set_tree_index(var, i >> (k + 1));
|
||||
p--;
|
||||
h0 = p >= 1 ? h[p - 1] : node;
|
||||
prm->h_h(var, h0, h0, h[p]);
|
||||
}
|
||||
i++; /* advance index */
|
||||
}
|
||||
}
|
||||
|
||||
/* === Generate an XMSS signature. */
|
||||
/* Algorithm 10: xmss_sign(M, SK.seed, idx, PK.seed, ADRS) */
|
||||
|
||||
static size_t xmss_sign(slh_var_t *var, uint8_t *sx, const uint8_t *m,
|
||||
uint32_t idx)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t j, k;
|
||||
uint8_t *auth;
|
||||
size_t sx_sz = 0;
|
||||
size_t n = prm->n;
|
||||
|
||||
sx_sz = get_len(prm) * n;
|
||||
auth = sx + sx_sz;
|
||||
|
||||
for (j = 0; j < prm->hp; j++)
|
||||
{
|
||||
k = (idx >> j) ^ 1;
|
||||
xmss_node(var, auth, k, j);
|
||||
auth += n;
|
||||
}
|
||||
sx_sz += prm->hp * n;
|
||||
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_WOTS_HASH);
|
||||
adrs_set_key_pair_address(var, idx);
|
||||
wots_sign(var, sx, m);
|
||||
|
||||
return sx_sz;
|
||||
}
|
||||
|
||||
/* === Compute an XMSS public key from an XMSS signature. */
|
||||
/* Algorithm 11: xmss_PKFromSig(idx, SIGXMSS, M, PK.seed, ADRS) */
|
||||
|
||||
static void xmss_pk_from_sig(slh_var_t *var, uint8_t *root, uint32_t idx,
|
||||
const uint8_t *sig, const uint8_t *m)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
size_t n = prm->n;
|
||||
uint32_t k;
|
||||
const uint8_t *auth;
|
||||
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_WOTS_HASH);
|
||||
adrs_set_key_pair_address(var, idx);
|
||||
|
||||
wots_pk_from_sig(var, root, sig, m);
|
||||
adrs_set_type_and_clear(var, ADRS_TREE);
|
||||
|
||||
auth = sig + (get_len(prm) * n);
|
||||
|
||||
for (k = 0; k < prm->hp; k++)
|
||||
{
|
||||
adrs_set_tree_height(var, k + 1);
|
||||
adrs_set_tree_index(var, idx >> (k + 1));
|
||||
|
||||
if (((idx >> k) & 1) == 0)
|
||||
{
|
||||
prm->h_h(var, root, root, auth);
|
||||
}
|
||||
else
|
||||
{
|
||||
prm->h_h(var, root, auth, root);
|
||||
}
|
||||
auth += n;
|
||||
}
|
||||
}
|
||||
|
||||
/* === Generate a hypertree signature. */
|
||||
/* Algorithm 12: ht_sign(M, SK.seed, PK.seed, idx_tree, idx_leaf ) */
|
||||
|
||||
static size_t ht_sign(slh_var_t *var, uint8_t *sh, uint8_t *m, uint64_t i_tree,
|
||||
uint32_t i_leaf)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t j;
|
||||
size_t sx_sz;
|
||||
|
||||
adrs_zero(var);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
sx_sz = xmss_sign(var, sh, m, i_leaf);
|
||||
|
||||
for (j = 1; j < prm->d; j++)
|
||||
{
|
||||
xmss_pk_from_sig(var, m, i_leaf, sh, m);
|
||||
sh += sx_sz;
|
||||
|
||||
i_leaf = i_tree & ((1 << prm->hp) - 1);
|
||||
i_tree >>= prm->hp;
|
||||
adrs_set_layer_address(var, j);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
xmss_sign(var, sh, m, i_leaf);
|
||||
}
|
||||
|
||||
return sx_sz * prm->d;
|
||||
}
|
||||
|
||||
/* === Verify a hypertree signature. */
|
||||
/* Algorithm 13: ht_verify(M, SIG_HT, PK.seed, idx_tree, idx_leaf, PK.root) */
|
||||
|
||||
static int ht_verify(slh_var_t *var, const uint8_t *m, const uint8_t *sig_ht,
|
||||
uint64_t i_tree, uint32_t i_leaf)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t j;
|
||||
uint8_t node[SLH_MAX_N] = {0};
|
||||
size_t st_sz;
|
||||
|
||||
adrs_zero(var);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
|
||||
xmss_pk_from_sig(var, node, i_leaf, sig_ht, m);
|
||||
|
||||
st_sz = (prm->hp + get_len(prm)) * prm->n;
|
||||
|
||||
for (j = 1; j < prm->d; j++)
|
||||
{
|
||||
i_leaf = i_tree & ((1 << prm->hp) - 1);
|
||||
i_tree >>= prm->hp;
|
||||
adrs_set_layer_address(var, j);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
sig_ht += st_sz;
|
||||
xmss_pk_from_sig(var, node, i_leaf, sig_ht, node);
|
||||
}
|
||||
|
||||
return memcmp(node, var->pk_root, prm->n) == 0;
|
||||
}
|
||||
|
||||
/* === Generate a FORS private-key value. */
|
||||
/* Algorithm 14: fors_SKgen(SK.seed, PK.seed, ADRS, idx) */
|
||||
|
||||
/* ( see prm->fors_hash() ) */
|
||||
|
||||
/* === Computes the root of a Merkle subtree of FORS public values. */
|
||||
/* Algorithm 15: fors_node(SK.seed, i, z, PK.seed, ADRS) */
|
||||
|
||||
static void fors_node(slh_var_t *var, uint8_t *node, uint32_t i, uint32_t z)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint8_t h[SLH_MAX_A][SLH_MAX_N], *h0;
|
||||
uint32_t j, k;
|
||||
int p;
|
||||
|
||||
p = -1;
|
||||
i <<= z;
|
||||
for (j = 0; j < (1u << z); j++)
|
||||
{
|
||||
/* fors_SKgen() + hash */
|
||||
adrs_set_tree_index(var, i);
|
||||
h0 = p >= 0 ? h[p] : node;
|
||||
p++;
|
||||
prm->fors_hash(var, h0, 1);
|
||||
|
||||
/* this fors_node() implementation is non-recursive */
|
||||
for (k = 0; (j >> k) & 1; k++)
|
||||
{
|
||||
adrs_set_tree_height(var, k + 1);
|
||||
adrs_set_tree_index(var, i >> (k + 1));
|
||||
p--;
|
||||
h0 = p > 0 ? h[p - 1] : node;
|
||||
prm->h_h(var, h0, h0, h[p]);
|
||||
}
|
||||
i++; /* advance index */
|
||||
}
|
||||
}
|
||||
|
||||
/* === Generates a FORS signature. */
|
||||
/* Algorithm 16: fors_sign(md, SK.seed, PK.seed, ADRS) */
|
||||
|
||||
static size_t fors_sign(slh_var_t *var, uint8_t *sf, const uint8_t *md)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t i, j, s;
|
||||
uint32_t vi[SLH_MAX_K];
|
||||
size_t n = prm->n;
|
||||
|
||||
base_2b(vi, md, prm->a, prm->k);
|
||||
|
||||
for (i = 0; i < prm->k; i++)
|
||||
{
|
||||
/* fors_SKgen() */
|
||||
adrs_set_tree_index(var, (i << prm->a) + vi[i]);
|
||||
prm->fors_hash(var, sf, 0);
|
||||
sf += n;
|
||||
|
||||
for (j = 0; j < prm->a; j++)
|
||||
{
|
||||
s = (vi[i] >> j) ^ 1;
|
||||
fors_node(var, sf, (i << (prm->a - j)) + s, j);
|
||||
sf += n;
|
||||
}
|
||||
}
|
||||
return n * prm->k * (1 + prm->a);
|
||||
}
|
||||
|
||||
/* === Compute a FORS public key from a FORS signature. */
|
||||
/* Algorithm 17: fors_pkFromSig(SIGFORS , md, PK.seed, ADRS) */
|
||||
|
||||
static void fors_pk_from_sig(slh_var_t *var, uint8_t *pk, const uint8_t *sf,
|
||||
const uint8_t *md)
|
||||
{
|
||||
const slh_param_t *prm = var->prm;
|
||||
uint32_t i, j, idx;
|
||||
uint32_t vi[SLH_MAX_K];
|
||||
uint8_t root[SLH_MAX_K * SLH_MAX_N];
|
||||
uint8_t *node;
|
||||
size_t n = prm->n;
|
||||
|
||||
base_2b(vi, md, prm->a, prm->k);
|
||||
|
||||
node = root;
|
||||
for (i = 0; i < prm->k; i++)
|
||||
{
|
||||
adrs_set_tree_height(var, 0);
|
||||
|
||||
idx = (i << prm->a) + vi[i];
|
||||
adrs_set_tree_index(var, idx);
|
||||
|
||||
prm->h_f(var, node, sf);
|
||||
sf += n;
|
||||
|
||||
for (j = 0; j < prm->a; j++)
|
||||
{
|
||||
adrs_set_tree_height(var, j + 1);
|
||||
adrs_set_tree_index(var, idx >> (j + 1));
|
||||
|
||||
if (((vi[i] >> j) & 1) == 0)
|
||||
{
|
||||
prm->h_h(var, node, node, sf);
|
||||
}
|
||||
else
|
||||
{
|
||||
prm->h_h(var, node, sf, node);
|
||||
}
|
||||
sf += n;
|
||||
}
|
||||
node += n;
|
||||
}
|
||||
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_FORS_ROOTS);
|
||||
prm->h_t(var, pk, root, prm->k * n);
|
||||
}
|
||||
|
||||
/* === Public API */
|
||||
|
||||
/* Return standard identifier string for parameter set *prm, or NULL. */
|
||||
const char *slh_alg_id(const slh_param_t *prm) { return prm->alg_id; }
|
||||
|
||||
/* Return public (verification) key size in bytes for parameter set *prm. */
|
||||
size_t slh_pk_sz(const slh_param_t *prm) { return 2 * prm->n; }
|
||||
|
||||
/* Return private (signing) key size in bytes for parameter set *prm. */
|
||||
size_t slh_sk_sz(const slh_param_t *prm) { return 4 * prm->n; }
|
||||
|
||||
/* === Generates an SLH-DSA key pair. */
|
||||
/* Algorithm 18: slh_keygen_internal(SK.seed, SK.prf, PK.seed) */
|
||||
|
||||
int slh_keygen_internal(uint8_t *sk, uint8_t *pk, const uint8_t *sk_seed,
|
||||
const uint8_t *sk_prf, const uint8_t *pk_seed,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
size_t n = prm->n;
|
||||
|
||||
memcpy(sk, sk_seed, n); /* SK_seed */
|
||||
memcpy(sk + n, sk_prf, n); /* SK.prf */
|
||||
memcpy(sk + 2 * n, pk_seed, n); /* PK.seed */
|
||||
memset(sk + 3 * n, 0x00, n); /* PK.root not generated yet */
|
||||
prm->mk_var(&var, NULL, sk, prm); /* fill in partial */
|
||||
|
||||
adrs_zero(&var);
|
||||
adrs_set_layer_address(&var, prm->d - 1);
|
||||
memcpy(pk, pk_seed, n); /* PK.seed in pk */
|
||||
xmss_node(&var, pk + n, 0, prm->hp); /* PK.root in pk (compute) */
|
||||
memcpy(sk + 3 * n, pk + n, n); /* PK.root in sk */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* === Generates an SLH-DSA key pair. */
|
||||
/* Algorithm 21: slh_keygen() */
|
||||
|
||||
int slh_keygen(uint8_t *sk, uint8_t *pk, int (*rbg)(uint8_t *x, size_t xlen),
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
uint8_t pk_root[SLH_MAX_N];
|
||||
size_t n = prm->n;
|
||||
|
||||
rbg(sk, 3 * n); /* SK.seed || SK.prf || PK.seed */
|
||||
memcpy(pk, sk + 2 * n, n); /* PK.seed */
|
||||
memset(sk + 3 * n, 0x00, n); /* PK.root not generated yet */
|
||||
prm->mk_var(&var, NULL, sk, prm); /* fill in partial */
|
||||
|
||||
adrs_zero(&var);
|
||||
adrs_set_layer_address(&var, prm->d - 1);
|
||||
xmss_node(&var, pk_root, 0, prm->hp);
|
||||
|
||||
/* fill pk_root */
|
||||
memcpy(sk + 3 * n, pk_root, n);
|
||||
memcpy(pk + n, pk_root, n);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* === sigGen === */
|
||||
|
||||
/* (Shared helper function for algorithms 18 and 19.) */
|
||||
|
||||
static void split_digest(uint64_t *i_tree, uint32_t *i_leaf,
|
||||
const uint8_t *digest, const slh_param_t *prm)
|
||||
{
|
||||
size_t md_sz = (prm->k * prm->a + 7) / 8;
|
||||
const uint8_t *pi_tree = digest + md_sz;
|
||||
size_t i_tree_sz = (prm->h - prm->hp + 7) / 8;
|
||||
size_t i_leaf_sz = (prm->hp + 7) / 8;
|
||||
const uint8_t *pi_leaf = pi_tree + i_tree_sz;
|
||||
|
||||
*i_tree = slh_toint(pi_tree, i_tree_sz);
|
||||
*i_leaf = slh_toint(pi_leaf, i_leaf_sz);
|
||||
if ((prm->h - prm->hp) != 64)
|
||||
{
|
||||
*i_tree &= (UINT64_C(1) << (prm->h - prm->hp)) - UINT64_C(1);
|
||||
}
|
||||
*i_leaf &= (1 << prm->hp) - 1;
|
||||
}
|
||||
|
||||
/* Core signing function that just takes in "digest" and an already */
|
||||
/* initialized secret key context. *sig points to signature after */
|
||||
/* randomizer. Returns the length of |SIG_FORS + SIG_HT| written at *sig. */
|
||||
|
||||
static size_t slh_sign_digest(slh_var_t *var, uint8_t *sig,
|
||||
const uint8_t *digest)
|
||||
{
|
||||
const uint8_t *md = digest;
|
||||
uint64_t i_tree = 0;
|
||||
uint32_t i_leaf = 0;
|
||||
uint8_t pk_fors[SLH_MAX_N] = {0};
|
||||
size_t sig_sz;
|
||||
|
||||
split_digest(&i_tree, &i_leaf, digest, var->prm);
|
||||
|
||||
adrs_zero(var);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_FORS_TREE);
|
||||
adrs_set_key_pair_address(var, i_leaf);
|
||||
|
||||
/* SIG_FORS */
|
||||
sig_sz = fors_sign(var, sig, md);
|
||||
fors_pk_from_sig(var, pk_fors, sig, md);
|
||||
|
||||
/* SIG_HT */
|
||||
sig += sig_sz;
|
||||
sig_sz += ht_sign(var, sig, pk_fors, i_tree, i_leaf);
|
||||
|
||||
return sig_sz;
|
||||
}
|
||||
|
||||
/* Algorithm 19: slh_sign_internal(M, SK, addrnd) */
|
||||
|
||||
size_t slh_sign_internal(uint8_t *sig, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *sk, const uint8_t *addrnd,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
const uint8_t *opt_rand;
|
||||
uint8_t digest[SLH_MAX_M];
|
||||
size_t sig_sz;
|
||||
|
||||
/* set up secret key etc */
|
||||
prm->mk_var(&var, NULL, sk, prm);
|
||||
|
||||
if (addrnd != NULL)
|
||||
{
|
||||
opt_rand = addrnd; /* randomnesss; non-determinsitic */
|
||||
}
|
||||
else
|
||||
{
|
||||
opt_rand = var.pk_seed; /* deterministic variant */
|
||||
}
|
||||
|
||||
/* randomized hashing; R (first part of signarure) */
|
||||
sig_sz = prm->n;
|
||||
prm->prf_msg(&var, sig, opt_rand, m, m_sz, NULL, SLH_CTX_SZ_NO_CONTEXT);
|
||||
prm->h_msg(&var, digest, sig, m, m_sz, NULL, SLH_CTX_SZ_NO_CONTEXT);
|
||||
|
||||
/* create FORS and HT signature parts */
|
||||
sig_sz += slh_sign_digest(&var, sig + sig_sz, digest);
|
||||
|
||||
return sig_sz;
|
||||
}
|
||||
|
||||
/* Algorithm 22: slh_sign(M, ctx, SK) */
|
||||
|
||||
size_t slh_sign(uint8_t *sig, const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz, const uint8_t *sk, const uint8_t *addrnd,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
const uint8_t *opt_rand;
|
||||
uint8_t digest[SLH_MAX_M] = {0};
|
||||
size_t sig_sz;
|
||||
|
||||
if (ctx_sz > 255)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* set up secret key etc */
|
||||
prm->mk_var(&var, NULL, sk, prm);
|
||||
|
||||
if (addrnd != NULL)
|
||||
{
|
||||
opt_rand = addrnd; /* randomnesss; non-determinsitic */
|
||||
}
|
||||
else
|
||||
{
|
||||
opt_rand = var.pk_seed; /* deterministic variant */
|
||||
}
|
||||
|
||||
/* randomized hashing; R (first part of signarure) */
|
||||
sig_sz = prm->n;
|
||||
prm->prf_msg(&var, sig, opt_rand, m, m_sz, ctx, ctx_sz);
|
||||
prm->h_msg(&var, digest, sig, m, m_sz, ctx, ctx_sz);
|
||||
|
||||
/* create FORS and HT signature parts */
|
||||
sig_sz += slh_sign_digest(&var, sig + sig_sz, digest);
|
||||
|
||||
return sig_sz;
|
||||
}
|
||||
|
||||
/* === sigVer === */
|
||||
|
||||
/* most of Algorithm 20: slh_verify_internal(M, SIG, PK) */
|
||||
|
||||
static int slh_verify_digest(slh_var_t *var, const uint8_t *digest,
|
||||
const uint8_t *sig, size_t sig_sz,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
uint8_t pk_fors[SLH_MAX_N] = { 0 };;
|
||||
const uint8_t *sig_fors;
|
||||
const uint8_t *sig_ht;
|
||||
const uint8_t *md = digest;
|
||||
uint64_t i_tree = 0;
|
||||
uint32_t i_leaf = 0;
|
||||
|
||||
sig_fors = sig + prm->n;
|
||||
sig_ht = sig + ((1 + prm->k * (1 + prm->a)) * prm->n);
|
||||
|
||||
/* check signature length */
|
||||
if (sig_sz != slh_sig_sz(prm))
|
||||
{
|
||||
return 0; /* false */
|
||||
}
|
||||
|
||||
split_digest(&i_tree, &i_leaf, digest, prm);
|
||||
|
||||
adrs_zero(var);
|
||||
adrs_set_tree_address(var, i_tree);
|
||||
adrs_set_type_and_clear_not_kp(var, ADRS_FORS_TREE);
|
||||
adrs_set_key_pair_address(var, i_leaf);
|
||||
|
||||
fors_pk_from_sig(var, pk_fors, sig_fors, md);
|
||||
|
||||
return ht_verify(var, pk_fors, sig_ht, i_tree, i_leaf);
|
||||
}
|
||||
|
||||
/* Algorithm 20: slh_verify_internal(M, SIG, PK) */
|
||||
|
||||
int slh_verify_internal(const uint8_t *m, size_t m_sz, const uint8_t *sig,
|
||||
size_t sig_sz, const uint8_t *pk,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
uint8_t digest[SLH_MAX_M];
|
||||
|
||||
/* use Hmsg directly */
|
||||
prm->mk_var(&var, pk, NULL, prm);
|
||||
prm->h_msg(&var, digest, sig, m, m_sz, NULL, SLH_CTX_SZ_NO_CONTEXT);
|
||||
|
||||
return slh_verify_digest(&var, digest, sig, sig_sz, prm);
|
||||
}
|
||||
|
||||
/* === Verifies a pure SLH-DSA signature. */
|
||||
/* Algorithm 24: slh_verify(M, SIG, ctx, PK) */
|
||||
|
||||
int slh_verify(const uint8_t *m, size_t m_sz, const uint8_t *sig, size_t sig_sz,
|
||||
const uint8_t *ctx, size_t ctx_sz, const uint8_t *pk,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
slh_var_t var;
|
||||
uint8_t digest[SLH_MAX_M];
|
||||
|
||||
if (ctx_sz > 255)
|
||||
{
|
||||
return 0; /* false */
|
||||
}
|
||||
|
||||
/* create the "pure" hash (with context) */
|
||||
prm->mk_var(&var, pk, NULL, prm);
|
||||
prm->h_msg(&var, digest, sig, m, m_sz, ctx, ctx_sz);
|
||||
|
||||
return slh_verify_digest(&var, digest, sig, sig_sz, prm);
|
||||
}
|
||||
85
src/sig/slh_dsa/slh_dsa_c/slh_dsa.h
Normal file
85
src/sig/slh_dsa/slh_dsa_c/slh_dsa.h
Normal file
@ -0,0 +1,85 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 205 Stateless Hash-Based Digital Signature Standard. */
|
||||
/* API fo internal and "pure" variants. */
|
||||
|
||||
#ifndef _SLH_DSA_H_
|
||||
#define _SLH_DSA_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifndef _SLH_PARAM_H_
|
||||
typedef struct slh_param_s slh_param_t;
|
||||
#endif
|
||||
|
||||
/* === SLH-DSA parameter sets */
|
||||
extern const slh_param_t slh_dsa_sha2_128s;
|
||||
extern const slh_param_t slh_dsa_shake_128s;
|
||||
extern const slh_param_t slh_dsa_sha2_128f;
|
||||
extern const slh_param_t slh_dsa_shake_128f;
|
||||
extern const slh_param_t slh_dsa_sha2_192s;
|
||||
extern const slh_param_t slh_dsa_shake_192s;
|
||||
extern const slh_param_t slh_dsa_sha2_192f;
|
||||
extern const slh_param_t slh_dsa_shake_192f;
|
||||
extern const slh_param_t slh_dsa_sha2_256s;
|
||||
extern const slh_param_t slh_dsa_shake_256s;
|
||||
extern const slh_param_t slh_dsa_sha2_256f;
|
||||
extern const slh_param_t slh_dsa_shake_256f;
|
||||
|
||||
/* === SLH_DSA API (_internal and _pure functions.) */
|
||||
/* see slh_prehash.h for HashSLH functions */
|
||||
|
||||
/* Return standard identifier string for parameter set *prm, or NULL. */
|
||||
const char *slh_alg_id(const slh_param_t *prm);
|
||||
|
||||
/* Return public (verification) key size in bytes for parameter set *prm. */
|
||||
size_t slh_pk_sz(const slh_param_t *prm);
|
||||
|
||||
/* Return private (signing) key size in bytes for parameter set *prm. */
|
||||
size_t slh_sk_sz(const slh_param_t *prm);
|
||||
|
||||
/* Return signature size in bytes for parameter set *prm. */
|
||||
size_t slh_sig_sz(const slh_param_t *prm);
|
||||
|
||||
/* Generate an SLH-DSA key pair; needs an RBG (a "randombytes()" function) */
|
||||
int slh_keygen(uint8_t *sk, uint8_t *pk, int (*rbg)(uint8_t *x, size_t xlen),
|
||||
const slh_param_t *prm);
|
||||
|
||||
int slh_keygen_internal(uint8_t *sk, uint8_t *pk, const uint8_t *sk_seed,
|
||||
const uint8_t *sk_prf, const uint8_t *pk_seed,
|
||||
const slh_param_t *prm);
|
||||
|
||||
/* Generate an SLH-DSA signature. */
|
||||
size_t slh_sign_internal(uint8_t *sig, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *sk, const uint8_t *addrnd,
|
||||
const slh_param_t *prm);
|
||||
|
||||
size_t slh_sign(uint8_t *sig, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *ctx, size_t ctx_sz, const uint8_t *sk,
|
||||
const uint8_t *addrnd, const slh_param_t *prm);
|
||||
|
||||
/* Verify an SLH-DSA signature. */
|
||||
/* return 0 on verification failure, 1 on success */
|
||||
int slh_verify_internal(const uint8_t *m, size_t m_sz, const uint8_t *sig,
|
||||
size_t sig_sz, const uint8_t *pk,
|
||||
const slh_param_t *prm);
|
||||
|
||||
int slh_verify(const uint8_t *m, size_t m_sz, const uint8_t *sig,
|
||||
size_t sig_sz, const uint8_t *ctx, size_t ctx_sz,
|
||||
const uint8_t *pk, const slh_param_t *prm);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* _SLH_DSA_H_ */
|
||||
#endif
|
||||
63
src/sig/slh_dsa/slh_dsa_c/slh_param.h
Normal file
63
src/sig/slh_dsa/slh_dsa_c/slh_param.h
Normal file
@ -0,0 +1,63 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Internal parameter definition structure. */
|
||||
|
||||
#ifndef _SLH_PARAM_H_
|
||||
#define _SLH_PARAM_H_
|
||||
|
||||
#include "plat_local.h"
|
||||
|
||||
/* address */
|
||||
typedef union
|
||||
{
|
||||
uint8_t u8[32];
|
||||
uint32_t u32[8];
|
||||
} adrs_t;
|
||||
|
||||
/* Parameter sets */
|
||||
|
||||
#ifndef _SLH_DSA_H_
|
||||
typedef struct slh_param_s slh_param_t;
|
||||
#endif
|
||||
typedef struct slh_var_s slh_var_t;
|
||||
|
||||
/* used to indicate _internal mode */
|
||||
#define SLH_CTX_SZ_NO_CONTEXT 0x100
|
||||
|
||||
struct slh_param_s
|
||||
{
|
||||
const char *alg_id; /* Algorithm name */
|
||||
|
||||
/* core parameters */
|
||||
uint32_t n; /* Security level / hash size { 16,24,32 }. */
|
||||
uint32_t h; /* Bits h used to select FORS key. */
|
||||
uint32_t d; /* Number of hypertree layers d. */
|
||||
uint32_t hp; /* Merkle tree height h' (XMSS). */
|
||||
uint32_t a; /* String length t = 2**a (FORS). */
|
||||
uint32_t k; /* Number of indices (FORS). */
|
||||
uint32_t lg_w; /* Number of bits in chain index (WOTS+) */
|
||||
uint32_t m; /* Length in bytes of message digest. */
|
||||
|
||||
/* hash function instantation */
|
||||
void (*mk_var)(slh_var_t *var, const uint8_t *pk, const uint8_t *sk,
|
||||
const slh_param_t *prm);
|
||||
void (*chain)(slh_var_t *var, uint8_t *tmp, const uint8_t *x, uint32_t i,
|
||||
uint32_t s);
|
||||
void (*wots_chain)(slh_var_t *var, uint8_t *tmp, uint32_t s);
|
||||
void (*fors_hash)(slh_var_t *var, uint8_t *tmp, uint32_t s);
|
||||
void (*h_msg)(slh_var_t *var, uint8_t *h, const uint8_t *r, const uint8_t *m,
|
||||
size_t m_sz, const uint8_t *ctx, size_t ctx_sz);
|
||||
void (*prf)(slh_var_t *var, uint8_t *h);
|
||||
void (*prf_msg)(slh_var_t *var, uint8_t *h, const uint8_t *opt_rand,
|
||||
const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz);
|
||||
void (*h_f)(slh_var_t *var, uint8_t *h, const uint8_t *m1);
|
||||
void (*h_h)(slh_var_t *var, uint8_t *h, const uint8_t *m1, const uint8_t *m2);
|
||||
void (*h_t)(slh_var_t *var, uint8_t *h, const uint8_t *m, size_t m_sz);
|
||||
};
|
||||
|
||||
/* _SLH_PARAM_H_ */
|
||||
#endif
|
||||
189
src/sig/slh_dsa/slh_dsa_c/slh_prehash.c
Normal file
189
src/sig/slh_dsa/slh_dsa_c/slh_prehash.c
Normal file
@ -0,0 +1,189 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
#include "slh_prehash.h"
|
||||
#include <string.h>
|
||||
#include "sha2_api.h"
|
||||
#include "sha3_api.h"
|
||||
#include "slh_dsa.h"
|
||||
#include "slh_var.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#define SLH_PREHASH_MAX_MP 512
|
||||
|
||||
/* shared formatting routine for alg 23 and alg 25 */
|
||||
|
||||
static size_t hash_slh_dsa_pad(uint8_t *mp, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *ctx, size_t ctx_sz,
|
||||
const char *ph)
|
||||
{
|
||||
size_t mp_sz = 0;
|
||||
|
||||
const uint8_t sha2_256_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x01};
|
||||
const uint8_t sha2_384_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x02};
|
||||
const uint8_t sha2_512_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x03};
|
||||
const uint8_t sha2_224_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x04};
|
||||
const uint8_t sha2_512_224_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x05};
|
||||
const uint8_t sha2_512_256_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x06};
|
||||
const uint8_t sha3_224_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x07};
|
||||
const uint8_t sha3_256_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x08};
|
||||
const uint8_t sha3_384_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x09};
|
||||
const uint8_t sha3_512_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x0A};
|
||||
const uint8_t shake_128_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x0B};
|
||||
const uint8_t shake_256_oid[11] = {0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
|
||||
0x65, 0x03, 0x04, 0x02, 0x0C};
|
||||
|
||||
if (ctx_sz > 255)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
mp[0] = 1;
|
||||
mp[1] = ctx_sz & 0xFF;
|
||||
memcpy(mp + 2, ctx, ctx_sz);
|
||||
mp_sz = 2 + ctx_sz;
|
||||
|
||||
if (strcmp(ph, "SHA2-256") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_256_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_256(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 32;
|
||||
}
|
||||
else if (strcmp(ph, "SHA2-384") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_384_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_384(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 48;
|
||||
}
|
||||
else if (strcmp(ph, "SHA2-512") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_512_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_512(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 64;
|
||||
}
|
||||
else if (strcmp(ph, "SHA2-224") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_224_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_224(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 28;
|
||||
}
|
||||
else if (strcmp(ph, "SHA2-512/224") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_512_224_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_512_224(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 28;
|
||||
}
|
||||
else if (strcmp(ph, "SHA2-512/256") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha2_512_256_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha2_512_256(mp + mp_sz, m, m_sz);
|
||||
mp_sz += 32;
|
||||
}
|
||||
else if (strcmp(ph, "SHA3-224") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha3_224_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha3(mp + mp_sz, 28, m, m_sz);
|
||||
mp_sz += 28;
|
||||
}
|
||||
else if (strcmp(ph, "SHA3-256") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha3_256_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha3(mp + mp_sz, 32, m, m_sz);
|
||||
mp_sz += 32;
|
||||
}
|
||||
else if (strcmp(ph, "SHA3-384") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha3_384_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha3(mp + mp_sz, 48, m, m_sz);
|
||||
mp_sz += 48;
|
||||
}
|
||||
else if (strcmp(ph, "SHA3-512") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, sha3_512_oid, 11);
|
||||
mp_sz += 11;
|
||||
sha3(mp + mp_sz, 64, m, m_sz);
|
||||
mp_sz += 64;
|
||||
}
|
||||
else if (strcmp(ph, "SHAKE-128") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, shake_128_oid, 11);
|
||||
mp_sz += 11;
|
||||
shake128(mp + mp_sz, 32, m, m_sz);
|
||||
mp_sz += 32;
|
||||
}
|
||||
else if (strcmp(ph, "SHAKE-256") == 0)
|
||||
{
|
||||
memcpy(mp + mp_sz, shake_256_oid, 11);
|
||||
mp_sz += 11;
|
||||
shake256(mp + mp_sz, 64, m, m_sz);
|
||||
mp_sz += 64;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return mp_sz;
|
||||
}
|
||||
|
||||
/* === Generates a pre-hash SLH-DSA signature. */
|
||||
/* Algorithm 23: hash_slh_sign(M, ctx, PH, SK) */
|
||||
|
||||
size_t hash_slh_sign(uint8_t *sig, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *ctx, size_t ctx_sz, const char *ph,
|
||||
const uint8_t *sk, const uint8_t *addrnd,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
uint8_t mp[SLH_PREHASH_MAX_MP];
|
||||
size_t mp_sz;
|
||||
|
||||
mp_sz = hash_slh_dsa_pad(mp, m, m_sz, ctx, ctx_sz, ph);
|
||||
if (mp_sz == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return slh_sign_internal(sig, mp, mp_sz, sk, addrnd, prm);
|
||||
}
|
||||
|
||||
/* === Verifies a pre-hash SLH-DSA signature. */
|
||||
/* Algorithm 25: hash_slh_verify(M, SIG, ctx, PH, PK) */
|
||||
|
||||
int hash_slh_verify(const uint8_t *m, size_t m_sz, const uint8_t *sig,
|
||||
size_t sig_sz, const uint8_t *ctx, size_t ctx_sz,
|
||||
const char *ph, const uint8_t *pk, const slh_param_t *prm)
|
||||
{
|
||||
uint8_t mp[SLH_PREHASH_MAX_MP];
|
||||
size_t mp_sz;
|
||||
|
||||
mp_sz = hash_slh_dsa_pad(mp, m, m_sz, ctx, ctx_sz, ph);
|
||||
if (mp_sz == 0)
|
||||
{
|
||||
return 0; /* false */
|
||||
}
|
||||
|
||||
return slh_verify_internal(mp, mp_sz, sig, sig_sz, pk, prm);
|
||||
}
|
||||
40
src/sig/slh_dsa/slh_dsa_c/slh_prehash.h
Normal file
40
src/sig/slh_dsa/slh_dsa_c/slh_prehash.h
Normal file
@ -0,0 +1,40 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === FIPS 205 Stateless Hash-Based Digital Signature Standard. */
|
||||
/* HashSLH functions */
|
||||
|
||||
#ifndef _SLH_PREHASH_H_
|
||||
#define _SLH_PREHASH_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include "slh_dsa.h"
|
||||
|
||||
/* === Generates a pre-hash SLH-DSA signature. */
|
||||
/* Algorithm 23: Algorithm 23 hash_slh_sign(M, ctx, PH, SK) */
|
||||
|
||||
size_t hash_slh_sign(uint8_t *sig, const uint8_t *m, size_t m_sz,
|
||||
const uint8_t *ctx, size_t ctx_sz, const char *ph,
|
||||
const uint8_t *sk, const uint8_t *addrnd,
|
||||
const slh_param_t *prm);
|
||||
|
||||
/* === Verifies a pre-hash SLH-DSA signature. */
|
||||
/* Algorithm 25: hash_slh_verify(M, SIG, ctx, PH, PK) */
|
||||
|
||||
int hash_slh_verify(const uint8_t *m, size_t m_sz, const uint8_t *sig,
|
||||
size_t sig_sz, const uint8_t *ctx, size_t ctx_sz,
|
||||
const char *ph, const uint8_t *pk,
|
||||
const slh_param_t *prm);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* _SLH_PREHASH_H_ */
|
||||
#endif
|
||||
581
src/sig/slh_dsa/slh_dsa_c/slh_sha2.c
Normal file
581
src/sig/slh_dsa/slh_dsa_c/slh_sha2.c
Normal file
@ -0,0 +1,581 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Portable C code: Functions for instantiation of SLH-DSA with SHA2 */
|
||||
|
||||
#include <string.h>
|
||||
#include "plat_local.h"
|
||||
#include "sha2_api.h"
|
||||
#include "slh_adrs.h"
|
||||
#include "slh_var.h"
|
||||
|
||||
/* Cat 1: Hmsg(R, PK.seed, PK.root, M) = */
|
||||
/* MGF1-SHA-256(R || PK.seed || SHA-256(R ||PK.seed || PK.root || */
|
||||
/* M), m) */
|
||||
|
||||
static void sha2_256_h_msg(slh_var_t *var, uint8_t *h, const uint8_t *r,
|
||||
const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz)
|
||||
{
|
||||
sha2_256_t sha2;
|
||||
size_t i;
|
||||
size_t n = var->prm->n;
|
||||
uint8_t buf[16 + 16 + 32 + 4];
|
||||
size_t mgf_sz;
|
||||
uint8_t *ctr;
|
||||
|
||||
/* SHA-256(R || PK.seed || PK.root || M) */
|
||||
sha2_256_init(&sha2);
|
||||
sha2_256_update(&sha2, r, n);
|
||||
sha2_256_update(&sha2, var->pk_seed, n);
|
||||
sha2_256_update(&sha2, var->pk_root, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
sha2_256_update(&sha2, buf, 2);
|
||||
sha2_256_update(&sha2, ctx, ctx_sz);
|
||||
}
|
||||
/* message */
|
||||
sha2_256_update(&sha2, m, m_sz);
|
||||
sha2_256_final(&sha2, buf + 2 * n);
|
||||
|
||||
/* MGF1-SHA-256(R || PK.seed || .. */
|
||||
memcpy(buf, r, n);
|
||||
memcpy(buf + n, var->pk_seed, n);
|
||||
|
||||
mgf_sz = 2 * n + 32 + 4;
|
||||
ctr = buf + mgf_sz - 4;
|
||||
|
||||
/* MGF1 counter mode */
|
||||
for (i = 0; i < var->prm->m; i += 32)
|
||||
{
|
||||
uint32_t c = i / 32;
|
||||
ctr[0] = c >> 24;
|
||||
ctr[1] = (c >> 16) & 0xFF;
|
||||
ctr[2] = (c >> 8) & 0xFF;
|
||||
ctr[3] = c & 0xFF;
|
||||
|
||||
sha2_256_init(&sha2);
|
||||
sha2_256_update(&sha2, buf, mgf_sz);
|
||||
if ((var->prm->m - i) >= 32)
|
||||
{
|
||||
sha2_256_final(&sha2, h + i);
|
||||
}
|
||||
else
|
||||
{
|
||||
sha2_256_final(&sha2, buf);
|
||||
memcpy(h + i, buf, var->prm->m - i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Cat 3, 5: Hmsg(R, PK.seed, PK.root, M) = */
|
||||
/* MGF1-SHA-512(R || PK.seed || SHA-512(R || PK.seed || PK.root || */
|
||||
/* M), m) */
|
||||
|
||||
static void sha2_512_h_msg(slh_var_t *var, uint8_t *h, const uint8_t *r,
|
||||
const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz)
|
||||
{
|
||||
size_t i;
|
||||
sha2_512_t sha2;
|
||||
uint8_t buf[32 + 32 + 64 + 4];
|
||||
size_t mgf_sz;
|
||||
uint8_t *ctr;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
/* SHA-512(R || PK.seed || PK.root || M) */
|
||||
sha2_512_init(&sha2);
|
||||
sha2_512_update(&sha2, r, n);
|
||||
sha2_512_update(&sha2, var->pk_seed, n);
|
||||
sha2_512_update(&sha2, var->pk_root, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
sha2_512_update(&sha2, buf, 2);
|
||||
sha2_512_update(&sha2, ctx, ctx_sz);
|
||||
}
|
||||
sha2_512_update(&sha2, m, m_sz);
|
||||
sha2_512_final(&sha2, buf + 2 * n);
|
||||
|
||||
/* MGF1-SHA-512(R || PK.seed || .. */
|
||||
memcpy(buf, r, n);
|
||||
memcpy(buf + n, var->pk_seed, n);
|
||||
|
||||
mgf_sz = 2 * n + 64 + 4;
|
||||
ctr = buf + mgf_sz - 4;
|
||||
|
||||
/* MGF1 counter mode */
|
||||
for (i = 0; i < var->prm->m; i += 64)
|
||||
{
|
||||
uint32_t c = i / 64;
|
||||
ctr[0] = c >> 24;
|
||||
ctr[1] = (c >> 16) & 0xFF;
|
||||
ctr[2] = (c >> 8) & 0xFF;
|
||||
ctr[3] = c & 0xFF;
|
||||
|
||||
sha2_512_init(&sha2);
|
||||
sha2_512_update(&sha2, buf, mgf_sz);
|
||||
if ((var->prm->m - i) >= 64)
|
||||
{
|
||||
sha2_512_final(&sha2, h + i);
|
||||
}
|
||||
else
|
||||
{
|
||||
sha2_512_final(&sha2, buf);
|
||||
memcpy(h + i, buf, var->prm->m - i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* insert ARDSc. */
|
||||
|
||||
static void sha2_256_adrsc(sha2_256_t *sha2, const slh_var_t *var)
|
||||
{
|
||||
uint8_t buf[22];
|
||||
adrsc_22(var, buf);
|
||||
sha2_256_update(sha2, buf, 22);
|
||||
}
|
||||
|
||||
static void sha2_512_adrsc(sha2_512_t *sha2, const slh_var_t *var)
|
||||
{
|
||||
uint8_t buf[22];
|
||||
adrsc_22(var, buf);
|
||||
sha2_512_update(sha2, buf, 22);
|
||||
}
|
||||
|
||||
/* Cat 1, 3, 5: PRF(PK.seed, SK.seed, ADRS) = */
|
||||
/* Trunc_n(SHA-256(PK.seed || toByte(0, 64 − n) || ADRSc || */
|
||||
/* SK.seed)) */
|
||||
|
||||
static void sha2_256_prf(slh_var_t *var, uint8_t *h)
|
||||
{
|
||||
sha2_256_t sha2;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
sha2_256_copy(&sha2, &var->sha2_256_pk_seed);
|
||||
sha2_256_adrsc(&sha2, var);
|
||||
sha2_256_update(&sha2, var->sk_seed, n);
|
||||
sha2_256_final_pad(&sha2);
|
||||
sha2_256_compress(sha2.s);
|
||||
memcpy(h, sha2.s, n);
|
||||
}
|
||||
|
||||
/* Cat 1: PRFmsg(SK.prf, opt_rand, M) = */
|
||||
/* Trunc_n(HMAC-SHA-256(SK.prf, opt_rand || M)) */
|
||||
|
||||
static void sha2_256_prf_msg(slh_var_t *var, uint8_t *h,
|
||||
const uint8_t *opt_rand, const uint8_t *m,
|
||||
size_t m_sz, const uint8_t *ctx, size_t ctx_sz)
|
||||
{
|
||||
unsigned i;
|
||||
sha2_256_t sha2;
|
||||
uint8_t pad[64], buf[32];
|
||||
size_t n = var->prm->n;
|
||||
|
||||
/* ipad */
|
||||
memcpy(pad, var->sk_prf, n);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
pad[i] ^= 0x36;
|
||||
}
|
||||
memset(pad + n, 0x36, 64 - n);
|
||||
|
||||
sha2_256_init(&sha2);
|
||||
sha2_256_update(&sha2, pad, 64);
|
||||
sha2_256_update(&sha2, opt_rand, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
sha2_256_update(&sha2, buf, 2);
|
||||
sha2_256_update(&sha2, ctx, ctx_sz);
|
||||
}
|
||||
sha2_256_update(&sha2, m, m_sz);
|
||||
sha2_256_final(&sha2, buf);
|
||||
|
||||
/* opad */
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
pad[i] ^= 0x36 ^ 0x5C;
|
||||
}
|
||||
|
||||
sha2_256_init(&sha2);
|
||||
sha2_256_update(&sha2, pad, 64);
|
||||
sha2_256_update(&sha2, buf, 32);
|
||||
sha2_256_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* Cat 3, 5: PRFmsg(SK.prf, opt_rand, M) = */
|
||||
/* Trunc_n(HMAC-SHA-512(SK.prf, opt_rand || M)) */
|
||||
|
||||
static void sha2_512_prf_msg(slh_var_t *var, uint8_t *h,
|
||||
const uint8_t *opt_rand, const uint8_t *m,
|
||||
size_t m_sz, const uint8_t *ctx, size_t ctx_sz)
|
||||
{
|
||||
unsigned i;
|
||||
sha2_512_t sha2;
|
||||
uint8_t pad[128], buf[64];
|
||||
size_t n = var->prm->n;
|
||||
|
||||
/* ipad */
|
||||
memcpy(pad, var->sk_prf, n);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
pad[i] ^= 0x36;
|
||||
}
|
||||
memset(pad + n, 0x36, 128 - n);
|
||||
|
||||
sha2_512_init(&sha2);
|
||||
sha2_512_update(&sha2, pad, 128);
|
||||
sha2_512_update(&sha2, opt_rand, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
sha2_512_update(&sha2, buf, 2);
|
||||
sha2_512_update(&sha2, ctx, ctx_sz);
|
||||
}
|
||||
sha2_512_update(&sha2, m, m_sz);
|
||||
sha2_512_final(&sha2, buf);
|
||||
|
||||
/* opad */
|
||||
for (i = 0; i < 128; i++)
|
||||
{
|
||||
pad[i] ^= 0x36 ^ 0x5C;
|
||||
}
|
||||
|
||||
sha2_512_init(&sha2);
|
||||
sha2_512_update(&sha2, pad, 128);
|
||||
sha2_512_update(&sha2, buf, 64);
|
||||
sha2_512_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* Cat 1: T_l(PK.seed, ADRS, M1 ) = */
|
||||
/* Trunc_n(SHA-256(PK.seed || toByte(0, 64 − n) || ADRSc || Ml )) */
|
||||
|
||||
static void sha2_256_tl(slh_var_t *var, uint8_t *h, const uint8_t *m,
|
||||
size_t m_sz)
|
||||
{
|
||||
sha2_256_t sha2;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
sha2_256_copy(&sha2, &var->sha2_256_pk_seed);
|
||||
sha2_256_adrsc(&sha2, var);
|
||||
sha2_256_update(&sha2, m, m_sz);
|
||||
sha2_256_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* Cat 1: F(PK.seed, ADRS, M1 ) = */
|
||||
/* Trunc_n(SHA-256(PK.seed || toByte(0, 64 − n) || ADRSc || M1 )) */
|
||||
|
||||
static void sha2_256_f(slh_var_t *var, uint8_t *h, const uint8_t *m1)
|
||||
{
|
||||
sha2_256_tl(var, h, m1, var->prm->n);
|
||||
}
|
||||
|
||||
/* Cat 1: H(PK.seed, ADRS, M2 ) = */
|
||||
/* Trunc_n(SHA-256(PK.seed || toByte(0, 64 − n) || ADRSc || M2 )) */
|
||||
|
||||
static void sha2_256_h(slh_var_t *var, uint8_t *h, const uint8_t *m1,
|
||||
const uint8_t *m2)
|
||||
{
|
||||
sha2_256_t sha2;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
sha2_256_copy(&sha2, &var->sha2_256_pk_seed);
|
||||
sha2_256_adrsc(&sha2, var);
|
||||
sha2_256_update(&sha2, m1, n);
|
||||
sha2_256_update(&sha2, m2, n);
|
||||
sha2_256_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* Cat 3, 5: Tl(PK.seed, ADRS, Ml ) = */
|
||||
/* Trunc_n(SHA-512(PK.seed || toByte(0, 128 − n) || ADRSc || Ml )) */
|
||||
|
||||
static void sha2_512_tl(slh_var_t *var, uint8_t *h, const uint8_t *m,
|
||||
size_t m_sz)
|
||||
{
|
||||
sha2_512_t sha2;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
sha2_512_copy(&sha2, &var->sha2_512_pk_seed);
|
||||
sha2_512_adrsc(&sha2, var);
|
||||
sha2_512_update(&sha2, m, m_sz);
|
||||
sha2_512_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* Cat 3, 5: H(PK.seed, ADRS, M2 ) = */
|
||||
/* Trunc_n(SHA-512(PK.seed || toByte(0, 128 − n) || ADRSc || M2 )) */
|
||||
|
||||
static void sha2_512_h(slh_var_t *var, uint8_t *h, const uint8_t *m1,
|
||||
const uint8_t *m2)
|
||||
{
|
||||
sha2_512_t sha2;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
sha2_512_copy(&sha2, &var->sha2_512_pk_seed);
|
||||
sha2_512_adrsc(&sha2, var);
|
||||
sha2_512_update(&sha2, m1, n);
|
||||
sha2_512_update(&sha2, m2, n);
|
||||
sha2_512_final_len(&sha2, h, n);
|
||||
}
|
||||
|
||||
/* create a context */
|
||||
|
||||
static void sha2_mk_var(slh_var_t *var, const uint8_t *pk, const uint8_t *sk,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
uint8_t buf[128 - 24];
|
||||
size_t n = prm->n;
|
||||
var->prm = prm;
|
||||
|
||||
var->prm = prm; /* store fixed parameters */
|
||||
if (sk != NULL)
|
||||
{
|
||||
memcpy(var->sk_seed, sk, n);
|
||||
memcpy(var->sk_prf, sk + n, n);
|
||||
memcpy(var->pk_seed, sk + 2 * n, n);
|
||||
memcpy(var->pk_root, sk + 3 * n, n);
|
||||
}
|
||||
else if (pk != NULL)
|
||||
{
|
||||
memcpy(var->pk_seed, pk, n);
|
||||
memcpy(var->pk_root, pk + n, n);
|
||||
}
|
||||
|
||||
/* eliminate the first compression function */
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
sha2_256_init(&var->sha2_256_pk_seed);
|
||||
sha2_256_update(&var->sha2_256_pk_seed, var->pk_seed, n);
|
||||
sha2_256_update(&var->sha2_256_pk_seed, buf, 64 - n);
|
||||
|
||||
if (n > 16)
|
||||
{
|
||||
sha2_512_init(&var->sha2_512_pk_seed);
|
||||
sha2_512_update(&var->sha2_512_pk_seed, var->pk_seed, n);
|
||||
sha2_512_update(&var->sha2_512_pk_seed, buf, 128 - n);
|
||||
}
|
||||
|
||||
/* local ADRS buffer */
|
||||
var->adrs = &var->t_adrs;
|
||||
}
|
||||
|
||||
/* === Chaining function used in WOTS+ */
|
||||
/* Algorithm 5: chain(X, i, s, PK.seed, ADRS) */
|
||||
|
||||
static void sha2_256_chain(slh_var_t *var, uint8_t *tmp, const uint8_t *x,
|
||||
uint32_t i, uint32_t s)
|
||||
{
|
||||
uint32_t j;
|
||||
size_t n = var->prm->n;
|
||||
sha2_256_t sha2;
|
||||
uint32_t sp[8 + 24];
|
||||
uint8_t *mp = (uint8_t *)&sp[8];
|
||||
uint8_t *op = (uint8_t *)&sha2.s[8];
|
||||
|
||||
/* these cases exist */
|
||||
if (s == 0)
|
||||
{
|
||||
memcpy(tmp, x, n);
|
||||
return;
|
||||
}
|
||||
|
||||
/* set initial address */
|
||||
adrs_set_hash_address(var, i);
|
||||
|
||||
/* initial set-up */
|
||||
sha2_256_copy(&sha2, &var->sha2_256_pk_seed);
|
||||
sha2_256_adrsc(&sha2, var);
|
||||
sha2_256_update(&sha2, x, n);
|
||||
if (s == 1)
|
||||
{
|
||||
/* just one hash */
|
||||
sha2_256_final_len(&sha2, tmp, n);
|
||||
return;
|
||||
}
|
||||
sha2_256_final_pad(&sha2);
|
||||
memcpy(sp, sha2.s, sizeof(sp));
|
||||
sha2_256_compress(sp);
|
||||
|
||||
/* iteration */
|
||||
for (j = 1; j < s; j++)
|
||||
{
|
||||
memcpy(mp + 22, sp, n); /* copy result back to input */
|
||||
slh_tobyte(mp + 18, i + j, 4); /* hash address, last part of ADSc */
|
||||
memcpy(sp, sha2.s, 32 + 18); /* PK.seed compressed, start of ADRSc */
|
||||
memcpy(mp + 22 + n, op + 22 + n, 64 - 22 - n); /* padding */
|
||||
sha2_256_compress(sp);
|
||||
}
|
||||
|
||||
/* final output */
|
||||
memcpy(tmp, sp, n);
|
||||
}
|
||||
|
||||
/* Combination WOTS PRF + Chain */
|
||||
|
||||
static void sha2_256_wots_chain(slh_var_t *var, uint8_t *tmp, uint32_t s)
|
||||
{
|
||||
/* PRF secret key */
|
||||
adrs_set_type(var, ADRS_WOTS_PRF);
|
||||
adrs_set_tree_index(var, 0);
|
||||
sha2_256_prf(var, tmp);
|
||||
|
||||
/* chain */
|
||||
adrs_set_type(var, ADRS_WOTS_HASH);
|
||||
adrs_set_tree_index(var, 0);
|
||||
sha2_256_chain(var, tmp, tmp, 0, s);
|
||||
}
|
||||
|
||||
/* Combination FORS PRF + F (if s == 1) */
|
||||
|
||||
static void sha2_256_fors_hash(slh_var_t *var, uint8_t *tmp, uint32_t s)
|
||||
{
|
||||
/* PRF secret key */
|
||||
adrs_set_type(var, ADRS_FORS_PRF);
|
||||
adrs_set_tree_height(var, 0);
|
||||
sha2_256_prf(var, tmp);
|
||||
|
||||
/* hash it again */
|
||||
if (s == 1)
|
||||
{
|
||||
adrs_set_type(var, ADRS_FORS_TREE);
|
||||
sha2_256_f(var, tmp, tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/* 10.2. SLH-DSA Using SHA2 for Security Category 1 */
|
||||
|
||||
const slh_param_t slh_dsa_sha2_128s = {/* .alg_id = */ "SLH-DSA-SHA2-128s",
|
||||
/* .n = */ 16,
|
||||
/* .h = */ 63,
|
||||
/* .d = */ 7,
|
||||
/* .hp = */ 9,
|
||||
/* .a = */ 12,
|
||||
/* .k = */ 14,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 30,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_256_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_256_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_256_h,
|
||||
/* .h_t = */ sha2_256_tl};
|
||||
|
||||
const slh_param_t slh_dsa_sha2_128f = {/* .alg_id = */ "SLH-DSA-SHA2-128f",
|
||||
/* .n = */ 16,
|
||||
/* .h = */ 66,
|
||||
/* .d = */ 22,
|
||||
/* .hp = */ 3,
|
||||
/* .a = */ 6,
|
||||
/* .k = */ 33,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 34,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_256_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_256_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_256_h,
|
||||
/* .h_t = */ sha2_256_tl};
|
||||
|
||||
/* 10.3. SLH-DSA Using SHA2 for Security Categories 3 and 5 */
|
||||
|
||||
const slh_param_t slh_dsa_sha2_192s = {/* .alg_id = */ "SLH-DSA-SHA2-192s",
|
||||
/* .n = */ 24,
|
||||
/* .h = */ 63,
|
||||
/* .d = */ 7,
|
||||
/* .hp = */ 9,
|
||||
/* .a = */ 14,
|
||||
/* .k = */ 17,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 39,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_512_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_512_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_512_h,
|
||||
/* .h_t = */ sha2_512_tl};
|
||||
|
||||
const slh_param_t slh_dsa_sha2_192f = {/* .alg_id = */ "SLH-DSA-SHA2-192f",
|
||||
/* .n = */ 24,
|
||||
/* .h = */ 66,
|
||||
/* .d = */ 22,
|
||||
/* .hp = */ 3,
|
||||
/* .a = */ 8,
|
||||
/* .k = */ 33,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 42,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_512_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_512_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_512_h,
|
||||
/* .h_t = */ sha2_512_tl};
|
||||
|
||||
const slh_param_t slh_dsa_sha2_256s = {/* .alg_id = */ "SLH-DSA-SHA2-256s",
|
||||
/* .n = */ 32,
|
||||
/* .h = */ 64,
|
||||
/* .d = */ 8,
|
||||
/* .hp = */ 8,
|
||||
/* .a = */ 14,
|
||||
/* .k = */ 22,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 47,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_512_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_512_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_512_h,
|
||||
/* .h_t = */ sha2_512_tl};
|
||||
|
||||
const slh_param_t slh_dsa_sha2_256f = {/* .alg_id = */ "SLH-DSA-SHA2-256f",
|
||||
/* .n = */ 32,
|
||||
/* .h = */ 68,
|
||||
/* .d = */ 17,
|
||||
/* .hp = */ 4,
|
||||
/* .a = */ 9,
|
||||
/* .k = */ 35,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 49,
|
||||
/* .mk_var = */ sha2_mk_var,
|
||||
/* .chain = */ sha2_256_chain,
|
||||
/* .wots_chain = */ sha2_256_wots_chain,
|
||||
/* .fors_hash = */ sha2_256_fors_hash,
|
||||
/* .h_msg = */ sha2_512_h_msg,
|
||||
/* .prf = */ sha2_256_prf,
|
||||
/* .prf_msg = */ sha2_512_prf_msg,
|
||||
/* .h_f = */ sha2_256_f,
|
||||
/* .h_h = */ sha2_512_h,
|
||||
/* .h_t = */ sha2_512_tl};
|
||||
351
src/sig/slh_dsa/slh_dsa_c/slh_shake.c
Normal file
351
src/sig/slh_dsa/slh_dsa_c/slh_shake.c
Normal file
@ -0,0 +1,351 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Portable C code: Functions for instantiation of SLH-DSA with SHAKE */
|
||||
|
||||
#include "sha3_api.h"
|
||||
#include "slh_adrs.h"
|
||||
#include "slh_var.h"
|
||||
|
||||
/* === 10.1. SLH-DSA Using SHAKE */
|
||||
|
||||
/* Hmsg(R, PK.seed, PK.root, M) = SHAKE256(R || PK.seed || PK.root || M, */
|
||||
/* 8m) */
|
||||
|
||||
static void shake_h_msg(slh_var_t *var, uint8_t *h, const uint8_t *r,
|
||||
const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
size_t n = var->prm->n;
|
||||
uint8_t buf[2];
|
||||
|
||||
shake256_init(&sha3);
|
||||
shake_update(&sha3, r, n);
|
||||
shake_update(&sha3, var->pk_seed, n);
|
||||
shake_update(&sha3, var->pk_root, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
shake_update(&sha3, buf, 2);
|
||||
shake_update(&sha3, ctx, ctx_sz);
|
||||
}
|
||||
shake_update(&sha3, m, m_sz);
|
||||
|
||||
shake_out(&sha3, h, var->prm->m);
|
||||
}
|
||||
|
||||
/* F(PK.seed, ADRS, M1 ) = SHAKE256(PK.seed || ADRS || M1, 8n) */
|
||||
|
||||
static void shake_f(slh_var_t *var, uint8_t *h, const uint8_t *m1)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
shake256_init(&sha3);
|
||||
shake_update(&sha3, var->pk_seed, n);
|
||||
shake_update(&sha3, (const uint8_t *)var->adrs->u8, 32);
|
||||
shake_update(&sha3, m1, n);
|
||||
|
||||
shake_out(&sha3, h, n);
|
||||
}
|
||||
|
||||
/* PRF(PK.seed, SK.seed, ADRS) = SHAKE256(PK.seed || ADRS || SK.seed, 8n) */
|
||||
|
||||
static void shake_prf(slh_var_t *var, uint8_t *h)
|
||||
{
|
||||
shake_f(var, h, var->sk_seed);
|
||||
}
|
||||
|
||||
/* PRFmsg (SK.prf, opt_rand, M) = SHAKE256(SK.prf || opt_rand || M, 8n) */
|
||||
|
||||
static void shake_prf_msg(slh_var_t *var, uint8_t *h, const uint8_t *opt_rand,
|
||||
const uint8_t *m, size_t m_sz, const uint8_t *ctx,
|
||||
size_t ctx_sz)
|
||||
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
size_t n = var->prm->n;
|
||||
uint8_t buf[2];
|
||||
|
||||
shake256_init(&sha3);
|
||||
shake_update(&sha3, var->sk_prf, n);
|
||||
shake_update(&sha3, opt_rand, n);
|
||||
|
||||
/* add "pure" domain separator and context, if supplied */
|
||||
if (ctx_sz != SLH_CTX_SZ_NO_CONTEXT)
|
||||
{
|
||||
buf[0] = 0;
|
||||
buf[1] = ctx_sz & 0xFF;
|
||||
shake_update(&sha3, buf, 2);
|
||||
shake_update(&sha3, ctx, ctx_sz);
|
||||
}
|
||||
shake_update(&sha3, m, m_sz);
|
||||
|
||||
shake_out(&sha3, h, n);
|
||||
}
|
||||
|
||||
/* T_l(PK.seed, ADRS, M ) = SHAKE256(PK.seed || ADRS || Ml, 8n) */
|
||||
|
||||
static void shake_t(slh_var_t *var, uint8_t *h, const uint8_t *m, size_t m_sz)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
shake256_init(&sha3);
|
||||
shake_update(&sha3, var->pk_seed, n);
|
||||
shake_update(&sha3, (const uint8_t *)var->adrs->u8, 32);
|
||||
shake_update(&sha3, m, m_sz);
|
||||
|
||||
shake_out(&sha3, h, n);
|
||||
}
|
||||
|
||||
/* H(PK.seed, ADRS, M2 ) = SHAKE256(PK.seed || ADRS || M2, 8n) */
|
||||
|
||||
static void shake_h(slh_var_t *var, uint8_t *h, const uint8_t *m1,
|
||||
const uint8_t *m2)
|
||||
{
|
||||
sha3_var_t sha3;
|
||||
size_t n = var->prm->n;
|
||||
|
||||
shake256_init(&sha3);
|
||||
shake_update(&sha3, var->pk_seed, n);
|
||||
shake_update(&sha3, (const uint8_t *)var->adrs->u8, 32);
|
||||
shake_update(&sha3, m1, n);
|
||||
shake_update(&sha3, m2, n);
|
||||
|
||||
shake_out(&sha3, h, n);
|
||||
}
|
||||
|
||||
/* create a context */
|
||||
|
||||
static void shake_mk_var(slh_var_t *var, const uint8_t *pk, const uint8_t *sk,
|
||||
const slh_param_t *prm)
|
||||
{
|
||||
size_t n = prm->n;
|
||||
|
||||
var->prm = prm; /* store fixed parameters */
|
||||
if (sk != NULL)
|
||||
{
|
||||
memcpy(var->sk_seed, sk, n);
|
||||
memcpy(var->sk_prf, sk + n, n);
|
||||
memcpy(var->pk_seed, sk + 2 * n, n);
|
||||
memcpy(var->pk_root, sk + 3 * n, n);
|
||||
}
|
||||
else if (pk != NULL)
|
||||
{
|
||||
memcpy(var->pk_seed, pk, n);
|
||||
memcpy(var->pk_root, pk + n, n);
|
||||
}
|
||||
|
||||
/* local ADRS buffer */
|
||||
var->adrs = &var->t_adrs;
|
||||
}
|
||||
|
||||
/* === Chaining function used in WOTS+ */
|
||||
/* Algorithm 5: chain(X, i, s, PK.seed, ADRS) */
|
||||
|
||||
/* chaining by processor (some optimizations) */
|
||||
|
||||
static void shake_chain(slh_var_t *var, uint8_t *tmp, const uint8_t *x,
|
||||
uint32_t i, uint32_t s)
|
||||
{
|
||||
uint32_t j, k;
|
||||
uint64_t ks[25];
|
||||
size_t n = var->prm->n;
|
||||
const uint32_t r = (1600 - 256 * 2) / 64; /* SHAKE256 rate */
|
||||
uint32_t n8 = n / 8; /* number of words */
|
||||
uint32_t h = n8 + (32 / 8); /* static part len */
|
||||
uint32_t l = h + n8; /* input length */
|
||||
|
||||
if (s == 0)
|
||||
{ /* no-op */
|
||||
memcpy(tmp, x, n);
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(ks + h, x, n); /* start node */
|
||||
for (j = 0; j < s; j++)
|
||||
{
|
||||
if (j > 0)
|
||||
{
|
||||
memcpy(ks + h, ks, n); /* chaining */
|
||||
}
|
||||
memcpy(ks, var->pk_seed, n); /* PK.seed */
|
||||
adrs_set_hash_address(var, i + j); /* address */
|
||||
memcpy(ks + n8, (const uint8_t *)var->adrs->u8, 32);
|
||||
|
||||
/* padding */
|
||||
ks[l] = 0x1F; /* shake padding */
|
||||
for (k = l + 1; k < r - 1; k++)
|
||||
{
|
||||
ks[k] = 0;
|
||||
}
|
||||
ks[r - 1] = UINT64_C(1) << 63; /* rate padding */
|
||||
for (k = r; k < 25; k++)
|
||||
{
|
||||
ks[k] = 0;
|
||||
}
|
||||
|
||||
keccak_f1600(ks); /* permutation */
|
||||
}
|
||||
memcpy(tmp, ks, n);
|
||||
}
|
||||
|
||||
/* Combination WOTS PRF + Chain */
|
||||
|
||||
static void shake_wots_chain(slh_var_t *var, uint8_t *tmp, uint32_t s)
|
||||
{
|
||||
/* PRF secret key */
|
||||
adrs_set_type(var, ADRS_WOTS_PRF);
|
||||
adrs_set_tree_index(var, 0);
|
||||
shake_prf(var, tmp);
|
||||
|
||||
/* chain */
|
||||
adrs_set_type(var, ADRS_WOTS_HASH);
|
||||
shake_chain(var, tmp, tmp, 0, s);
|
||||
}
|
||||
|
||||
/* Combination FORS PRF + F (if s == 1) */
|
||||
|
||||
static void shake_fors_hash(slh_var_t *var, uint8_t *tmp, uint32_t s)
|
||||
{
|
||||
/* PRF secret key */
|
||||
adrs_set_type(var, ADRS_FORS_PRF);
|
||||
adrs_set_tree_height(var, 0);
|
||||
shake_prf(var, tmp);
|
||||
|
||||
/* hash it again */
|
||||
if (s == 1)
|
||||
{
|
||||
adrs_set_type(var, ADRS_FORS_TREE);
|
||||
shake_f(var, tmp, tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/* parameter sets */
|
||||
|
||||
const slh_param_t slh_dsa_shake_128s = {/* .alg_id = */ "SLH-DSA-SHAKE-128s",
|
||||
/* .n = */ 16,
|
||||
/* .h = */ 63,
|
||||
/* .d = */ 7,
|
||||
/* .hp = */ 9,
|
||||
/* .a = */ 12,
|
||||
/* .k = */ 14,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 30,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
|
||||
const slh_param_t slh_dsa_shake_128f = {/* .alg_id = */ "SLH-DSA-SHAKE-128f",
|
||||
/* .n = */ 16,
|
||||
/* .h = */ 66,
|
||||
/* .d = */ 22,
|
||||
/* .hp = */ 3,
|
||||
/* .a = */ 6,
|
||||
/* .k = */ 33,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 34,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
|
||||
const slh_param_t slh_dsa_shake_192s = {/* .alg_id = */ "SLH-DSA-SHAKE-192s",
|
||||
/* .n = */ 24,
|
||||
/* .h = */ 63,
|
||||
/* .d = */ 7,
|
||||
/* .hp = */ 9,
|
||||
/* .a = */ 14,
|
||||
/* .k = */ 17,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 39,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
|
||||
const slh_param_t slh_dsa_shake_192f = {/* .alg_id = */ "SLH-DSA-SHAKE-192f",
|
||||
/* .n = */ 24,
|
||||
/* .h = */ 66,
|
||||
/* .d = */ 22,
|
||||
/* .hp = */ 3,
|
||||
/* .a = */ 8,
|
||||
/* .k = */ 33,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 42,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
|
||||
const slh_param_t slh_dsa_shake_256s = {/* .alg_id = */ "SLH-DSA-SHAKE-256s",
|
||||
/* .n = */ 32,
|
||||
/* .h = */ 64,
|
||||
/* .d = */ 8,
|
||||
/* .hp = */ 8,
|
||||
/* .a = */ 14,
|
||||
/* .k = */ 22,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 47,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
|
||||
const slh_param_t slh_dsa_shake_256f = {/* .alg_id = */ "SLH-DSA-SHAKE-256f",
|
||||
/* .n = */ 32,
|
||||
/* .h = */ 68,
|
||||
/* .d = */ 17,
|
||||
/* .hp = */ 4,
|
||||
/* .a = */ 9,
|
||||
/* .k = */ 35,
|
||||
/* .lg_w = */ 4,
|
||||
/* .m = */ 49,
|
||||
/* .mk_var = */ shake_mk_var,
|
||||
/* .chain = */ shake_chain,
|
||||
/* .wots_chain = */ shake_wots_chain,
|
||||
/* .fors_hash = */ shake_fors_hash,
|
||||
/* .h_msg = */ shake_h_msg,
|
||||
/* .prf = */ shake_prf,
|
||||
/* .prf_msg = */ shake_prf_msg,
|
||||
/* .h_f = */ shake_f,
|
||||
/* .h_h = */ shake_h,
|
||||
/* .h_t = */ shake_t};
|
||||
61
src/sig/slh_dsa/slh_dsa_c/slh_var.h
Normal file
61
src/sig/slh_dsa/slh_dsa_c/slh_var.h
Normal file
@ -0,0 +1,61 @@
|
||||
/*
|
||||
* Copyright (c) The slhdsa-c project authors
|
||||
* SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
|
||||
*/
|
||||
|
||||
/* === Internal parameter definition structure. */
|
||||
|
||||
#ifndef _SLH_VAR_H_
|
||||
#define _SLH_VAR_H_
|
||||
|
||||
#include "sha2_api.h"
|
||||
#include "slh_param.h"
|
||||
|
||||
/* some structural sizes */
|
||||
|
||||
#ifdef SLH_EXPERIMENTAL
|
||||
|
||||
/* a and hp adjusted to facilitate experimental parameter sets */
|
||||
#define SLH_MAX_N 32
|
||||
#define SLH_MAX_LEN (2 * SLH_MAX_N + 3)
|
||||
#define SLH_MAX_K 35
|
||||
#define SLH_MAX_HP 20
|
||||
#define SLH_MAX_A 24
|
||||
#define SLH_MAX_M 49
|
||||
|
||||
#else /* !SLH_EXPERIMENTAL */
|
||||
|
||||
/* maximum parameter sizes for FIPS 205 parameters */
|
||||
#define SLH_MAX_N 32
|
||||
#define SLH_MAX_LEN (2 * SLH_MAX_N + 3)
|
||||
#define SLH_MAX_K 35
|
||||
#define SLH_MAX_HP 9
|
||||
#define SLH_MAX_A 14
|
||||
#define SLH_MAX_M 49
|
||||
|
||||
#endif
|
||||
|
||||
/* context */
|
||||
struct slh_var_s
|
||||
{
|
||||
const slh_param_t *prm;
|
||||
uint8_t sk_seed[SLH_MAX_N];
|
||||
uint8_t sk_prf[SLH_MAX_N];
|
||||
uint8_t pk_seed[SLH_MAX_N];
|
||||
uint8_t pk_root[SLH_MAX_N];
|
||||
|
||||
adrs_t *adrs; /* regular pointer */
|
||||
adrs_t t_adrs; /* local ADRS buffer */
|
||||
|
||||
/* precomputed values */
|
||||
sha2_256_t sha2_256_pk_seed;
|
||||
sha2_512_t sha2_512_pk_seed;
|
||||
};
|
||||
|
||||
/* === Lower-level functions */
|
||||
|
||||
/* Core signing function (of a randomized digest) with initialized context. */
|
||||
size_t slh_do_sign(slh_var_t *var, uint8_t *sig, const uint8_t *digest);
|
||||
|
||||
/* _SLH_VAR_H_ */
|
||||
#endif
|
||||
17
src/sig/slh_dsa/templates/slh_dsa_alg_support_template.jinja
Normal file
17
src/sig/slh_dsa/templates/slh_dsa_alg_support_template.jinja
Normal file
@ -0,0 +1,17 @@
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_START
|
||||
ADD_ENABLE_BY_ALG LIST_STANDARDIZED_ALGS
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ENABLE_BY_ALG_START
|
||||
option(OQS_ENABLE_SIG_SLH_DSA "Enable slh_dsa algorithm family" ON)
|
||||
{% for variant in variants -%}
|
||||
cmake_dependent_option(OQS_ENABLE_SIG_slh_dsa_{{variant}} "" ON "OQS_ENABLE_SIG_SLH_DSA" OFF)
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ENABLE_BY_ALG_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_LIST_STANDARDIZED_ALGS_START
|
||||
filter_algs("{% for variant in variants -%}
|
||||
SIG_slh_dsa_{{variant}};
|
||||
{%- endfor %}")
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_LIST_STANDARDIZED_ALGS_END
|
||||
19
src/sig/slh_dsa/templates/slh_dsa_cmake_template.jinja
Normal file
19
src/sig/slh_dsa/templates/slh_dsa_cmake_template.jinja
Normal file
@ -0,0 +1,19 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
|
||||
set(_SLH_DSA_OBJS "")
|
||||
|
||||
if(OQS_ENABLE_SIG_SLH_DSA)
|
||||
add_library(slh_dsa_c OBJECT
|
||||
{% for file in sources -%}
|
||||
{{ file }}
|
||||
{% endfor %}
|
||||
)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/slh_dsa_c)
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/pure)
|
||||
{% for prehashHashAlg in prehashHashAlgs -%}
|
||||
target_include_directories(slh_dsa_c PRIVATE ${CMAKE_CURRENT_LIST_DIR}/wrappers/prehash_{{prehashHashAlg}})
|
||||
{% endfor %}
|
||||
set(_SLH_DSA_OBJS ${_SLH_DSA_OBJS} $<TARGET_OBJECTS:slh_dsa_c>)
|
||||
endif()
|
||||
|
||||
set(SLH_DSA_OBJS ${_SLH_DSA_OBJS} PARENT_SCOPE)
|
||||
43
src/sig/slh_dsa/templates/slh_dsa_header_template.jinja
Normal file
43
src/sig/slh_dsa/templates/slh_dsa_header_template.jinja
Normal file
@ -0,0 +1,43 @@
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_0_START
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#ifndef OQS_SIG_SLH_DSA_H
|
||||
#define OQS_SIG_SLH_DSA_H
|
||||
|
||||
#include <oqs/oqs.h>
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_0_END
|
||||
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_BODY_START
|
||||
{% if pure == true %}
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}})
|
||||
#define OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_public_key {{pkSize}}
|
||||
#define OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_secret_key {{skSize}}
|
||||
#define OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_signature {{sigSize}}
|
||||
|
||||
OQS_SIG *OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_new(void);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_keypair(uint8_t *public_key, uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key);
|
||||
#endif
|
||||
{% else %}
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}})
|
||||
#define OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_public_key {{pkSize}}
|
||||
#define OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_secret_key {{skSize}}
|
||||
#define OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_signature {{sigSize}}
|
||||
|
||||
OQS_SIG *OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_new(void);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_keypair(uint8_t *public_key, uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key);
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key);
|
||||
#endif
|
||||
{% endif %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_BODY_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_2_START
|
||||
#endif
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_2_END
|
||||
11
src/sig/slh_dsa/templates/slh_dsa_oqsconfig_template.jinja
Normal file
11
src/sig/slh_dsa/templates/slh_dsa_oqsconfig_template.jinja
Normal file
@ -0,0 +1,11 @@
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_START
|
||||
ADD_ALG_ENABLE_DEFINES
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_END
|
||||
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START
|
||||
#cmakedefine OQS_ENABLE_SIG_SLH_DSA 1
|
||||
{% for variant in variants -%}
|
||||
#cmakedefine OQS_ENABLE_SIG_slh_dsa_{{variant}} 1
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END
|
||||
31
src/sig/slh_dsa/templates/slh_dsa_sig_c_template.jinja
Normal file
31
src/sig/slh_dsa/templates/slh_dsa_sig_c_template.jinja
Normal file
@ -0,0 +1,31 @@
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_START
|
||||
ALGID ENABLED SIGNEW
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_START
|
||||
{% for variant in variants -%}
|
||||
OQS_SIG_alg_slh_dsa_{{variant}},
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ENABLED_START
|
||||
{% for variant in variants -%}
|
||||
} else if (0 == strcasecmp(method_name, OQS_SIG_alg_slh_dsa_{{variant}})) {
|
||||
#ifdef OQS_ENABLE_SIG_slh_dsa_{{variant}}
|
||||
return 1;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ENABLED_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_SIGNEW_START
|
||||
{% for variant in variants -%}
|
||||
} else if (0 == strcasecmp(method_name, OQS_SIG_alg_slh_dsa_{{variant}})) {
|
||||
#ifdef OQS_ENABLE_SIG_slh_dsa_{{variant}}
|
||||
return OQS_SIG_slh_dsa_{{variant}}_new();
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_SIGNEW_END
|
||||
24
src/sig/slh_dsa/templates/slh_dsa_sig_h_template.jinja
Normal file
24
src/sig/slh_dsa/templates/slh_dsa_sig_h_template.jinja
Normal file
@ -0,0 +1,24 @@
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_START
|
||||
ALGID ALGS_LENGTH INCLUDE
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_IDENTIFIER_LIST_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_START
|
||||
{% for variant in variants -%}
|
||||
/** Algorithm identifier for slh_dsa_{{variant}} */
|
||||
#define OQS_SIG_alg_slh_dsa_{{ variant }} "SLH_DSA_{{ variant|upper }}"
|
||||
{% endfor %}
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_START
|
||||
{% set unary %}{% for variant in variants %}1{% endfor %}{% endset %}
|
||||
/** Number of algorithm identifiers above. */
|
||||
#define OQS_SIG_SLH_DSA_algs_length {{ unary|length }}
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_END
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_START
|
||||
#ifdef OQS_ENABLE_SIG_SLH_DSA
|
||||
#include <oqs/sig_slh_dsa.h>
|
||||
#endif /* OQS_ENABLE_SIG_SLH_DSA */
|
||||
|
||||
##### OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_END
|
||||
236
src/sig/slh_dsa/templates/slh_dsa_src_template.jinja
Normal file
236
src/sig/slh_dsa/templates/slh_dsa_src_template.jinja
Normal file
@ -0,0 +1,236 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
{% if pure == true %}
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}})
|
||||
OQS_SIG *OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_pure_{{hashAlg}}_{{paramSet}};
|
||||
sig->alg_version = "{{algVersion}}";
|
||||
|
||||
sig->claimed_nist_level = {{claimedNISTLevel}};
|
||||
sig->euf_cma = {{eufCMA}};
|
||||
sig->suf_cma = {{sufCMA}};
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign(uint8_t *signature, size_t *signature_len,
|
||||
const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
const uint8_t *ctx;
|
||||
const size_t ctxlen = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = slh_sign(signature,message,message_len,ctx,ctxlen,
|
||||
secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify(const uint8_t *message, size_t message_len,
|
||||
const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
const uint8_t *ctx;
|
||||
const size_t ctxlen = 0;
|
||||
|
||||
int res = slh_verify(message,message_len,signature,signature_len, ctx,
|
||||
ctxlen,public_key, prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = slh_sign(signature,message,message_len,ctx_str,ctx_str_len,
|
||||
secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
|
||||
int res = slh_verify(message,message_len,signature,signature_len,ctx_str,
|
||||
ctx_str_len,public_key, prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
{% else %}
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}})
|
||||
OQS_SIG *OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}};
|
||||
sig->alg_version = "{{algVersion}}";
|
||||
|
||||
sig->claimed_nist_level = {{claimedNISTLevel}};
|
||||
sig->euf_cma = {{eufCMA}};
|
||||
sig->suf_cma = {{sufCMA}};
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
|
||||
const char *ph = "{{ prehashHashAlg|replace('_', '-')|upper }}";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
const char *ph = "{{ prehashHashAlg|replace('_', '-')|upper }}";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
const char *ph = "{{ prehashHashAlg|replace('_', '-')|upper }}";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_{{prehashHashAlg}}_prehash_{{hashAlg}}_{{paramSet}}_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_{{hashAlg}}_{{paramSet}};
|
||||
const char *ph = "{{ prehashHashAlg|replace('_', '-')|upper }}";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
{% endif %}
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-384";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_128s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_192s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256f;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256s;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_shake_256s;
|
||||
const char *ph = "SHA2-512-224";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../../sig_slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_dsa.h"
|
||||
#include "../../slh_dsa_c/slh_prehash.h"
|
||||
#include <oqs/oqs.h>
|
||||
|
||||
|
||||
#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f)
|
||||
OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_new(void) {
|
||||
|
||||
OQS_SIG *sig = OQS_MEM_malloc(sizeof(OQS_SIG));
|
||||
if (sig == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
sig->method_name = OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128f;
|
||||
sig->alg_version = "FIPS205";
|
||||
|
||||
sig->claimed_nist_level = 1;
|
||||
sig->euf_cma = true;
|
||||
sig->suf_cma = true;
|
||||
sig->sig_with_ctx_support = true;
|
||||
|
||||
sig->length_public_key = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_public_key;
|
||||
sig->length_secret_key = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_secret_key;
|
||||
sig->length_signature = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_signature;
|
||||
|
||||
sig->keypair = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_keypair;
|
||||
sig->sign = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign;
|
||||
sig->verify = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify;
|
||||
sig->sign_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign_with_ctx_str;
|
||||
sig->verify_with_ctx_str = OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify_with_ctx_str;
|
||||
|
||||
return sig;
|
||||
}
|
||||
|
||||
static int slh_randombytes(uint8_t *x, size_t xlen)
|
||||
{
|
||||
OQS_randombytes(x,xlen);
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
int (*rbg)(uint8_t *x, size_t xlen) = slh_randombytes;
|
||||
return slh_keygen(secret_key,public_key, rbg, prm);
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key) {
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
|
||||
const char *ph = "SHA2-512-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-256";
|
||||
const uint8_t *ctx_str;
|
||||
const size_t ctx_str_len = 0;
|
||||
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature,
|
||||
size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *secret_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-256";
|
||||
uint8_t addrnd[16];
|
||||
OQS_randombytes(addrnd, 16);
|
||||
|
||||
*signature_len = hash_slh_sign(signature,message,message_len,ctx_str,
|
||||
ctx_str_len,ph,secret_key,addrnd,prm);
|
||||
|
||||
if(*signature_len == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message,
|
||||
size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str,
|
||||
size_t ctx_str_len, const uint8_t *public_key) {
|
||||
|
||||
const slh_param_t *prm = &slh_dsa_sha2_128f;
|
||||
const char *ph = "SHA2-512-256";
|
||||
int res = hash_slh_verify(message,message_len,signature,signature_len,
|
||||
ctx_str,ctx_str_len,ph,public_key,prm);
|
||||
|
||||
if(res == 0)
|
||||
{
|
||||
return OQS_ERROR;
|
||||
}
|
||||
return OQS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user