mirror of
https://github.com/Mbed-TLS/mbedtls.git
synced 2025-07-29 11:41:15 +03:00
Merge pull request #51 from Patater/update-dev-tls-dev-crypto-merge
Merge mbedtls/development-psa, mbedtls/development into development
This commit is contained in:
Jaeden Amero
GitHub
@ -72,6 +72,7 @@ add_test_suite(cipher cipher.chacha20)
|
||||
add_test_suite(cipher cipher.chachapoly)
|
||||
add_test_suite(cipher cipher.des)
|
||||
add_test_suite(cipher cipher.gcm)
|
||||
add_test_suite(cipher cipher.misc)
|
||||
add_test_suite(cipher cipher.null)
|
||||
add_test_suite(cipher cipher.padding)
|
||||
add_test_suite(cmac)
|
||||
@ -92,6 +93,7 @@ add_test_suite(gcm gcm.aes128_de)
|
||||
add_test_suite(gcm gcm.aes192_de)
|
||||
add_test_suite(gcm gcm.aes256_de)
|
||||
add_test_suite(gcm gcm.camellia)
|
||||
add_test_suite(gcm gcm.misc)
|
||||
add_test_suite(hkdf)
|
||||
add_test_suite(hmac_drbg hmac_drbg.misc)
|
||||
add_test_suite(hmac_drbg hmac_drbg.no_reseed)
|
||||
|
||||
@ -21,7 +21,7 @@ FAILED=0
|
||||
SKIPPED=0
|
||||
SRVMEM=0
|
||||
|
||||
# default commands, can be overriden by the environment
|
||||
# default commands, can be overridden by the environment
|
||||
: ${M_SRV:=../programs/ssl/ssl_server2}
|
||||
: ${M_CLI:=../programs/ssl/ssl_client2}
|
||||
: ${OPENSSL_CMD:=openssl} # OPENSSL would conflict with the build system
|
||||
|
||||
16
tests/data_files/server1-ms.req.sha256
Normal file
16
tests/data_files/server1-ms.req.sha256
Normal file
@ -0,0 +1,16 @@
|
||||
-----BEGIN NEW CERTIFICATE REQUEST-----
|
||||
MIICgTCCAWkCAQAwPDELMAkGA1UEBhMCTkwxETAPBgNVBAoTCFBvbGFyU1NMMRow
|
||||
GAYDVQQDExFQb2xhclNTTCBTZXJ2ZXIgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP
|
||||
ADCCAQoCggEBAKkCHz1AatVVU4v9Nu6CZS4VYV6Jv7joRZDb7ogWUtPxQ1BHlhJZ
|
||||
ZIdr/SvgRvlzvt3PkuGRW+1moG+JKXlFgNCDatVBQ3dfOXwJBEeCsFc5cO2j7BUZ
|
||||
HqgzCEfBBUKp/UzDtN/dBh9NEFFAZ3MTD0D4bYElXwqxU8YwfhU5rPla7n+SnqYF
|
||||
W+cTl4W1I5LZ1CQG1QkliXUH3aYajz8JGb6tZSxk65Wb3P5BXhem2mxbacwCuhQs
|
||||
FiScStzN0PdSZ3PxLaAj/X70McotcMqJCwTbLqZPcG6ezr1YieJTWZ5uWpJl4og/
|
||||
DJQZo93l6J2VE+0p26twEtxaymsXq1KCVLECAwEAAaAAMA0GCSqGSIb3DQEBCwUA
|
||||
A4IBAQBY/1nnYQ3ThVyeZb1Z2wLYoHZ5rfeJCedyP7N/gjJZjhrMbwioUft2uHpb
|
||||
+OZQfxRXJTbtj/1wpRMCoUMLWzapS7/xGx3IjoPtl42aM4M+xVYvbLjExL13kUAr
|
||||
eE4JWcMIbTEPol2zSdX/LuB+m27jEp5VsvM2ty9qOw/T4iKwjFSe6pcYZ2spks19
|
||||
3ltgjnaamwqKcN9zUA3IERTsWjr5exKYgfXm2OeeuSP0tHr7Dh+w/2XA9dGcLhrm
|
||||
TA4P8QjIgSDlyzmhYYmsrioFPuCfdi1uzs8bxmbLXbiCGZ8TDMy5oLqLo1K+j2pF
|
||||
ox+ATHKxQ/XpRQP+2OTb9sw1kM59
|
||||
-----END NEW CERTIFICATE REQUEST-----
|
||||
@ -120,7 +120,7 @@ pre_initialize_variables () {
|
||||
FORCE=0
|
||||
KEEP_GOING=0
|
||||
|
||||
# Default commands, can be overriden by the environment
|
||||
# Default commands, can be overridden by the environment
|
||||
: ${OPENSSL:="openssl"}
|
||||
: ${OPENSSL_LEGACY:="$OPENSSL"}
|
||||
: ${OPENSSL_NEXT:="$OPENSSL"}
|
||||
@ -227,7 +227,7 @@ cleanup()
|
||||
command make clean
|
||||
|
||||
# Remove CMake artefacts
|
||||
find . -name .git -prune \
|
||||
find . -name .git -prune -o \
|
||||
-iname CMakeFiles -exec rm -rf {} \+ -o \
|
||||
\( -iname cmake_install.cmake -o \
|
||||
-iname CTestTestfile.cmake -o \
|
||||
@ -393,6 +393,12 @@ pre_check_git () {
|
||||
fi
|
||||
}
|
||||
|
||||
pre_check_seedfile () {
|
||||
if [ ! -f "./tests/seedfile" ]; then
|
||||
dd if=/dev/urandom of=./tests/seedfile bs=32 count=1
|
||||
fi
|
||||
}
|
||||
|
||||
pre_setup_keep_going () {
|
||||
failure_summary=
|
||||
failure_count=0
|
||||
@ -774,6 +780,59 @@ component_build_default_make_gcc_and_cxx () {
|
||||
make TEST_CPP=1
|
||||
}
|
||||
|
||||
component_test_use_psa_crypto_full_cmake_asan() {
|
||||
# MBEDTLS_USE_PSA_CRYPTO: run the same set of tests as basic-build-test.sh
|
||||
msg "build: cmake, full config + MBEDTLS_USE_PSA_CRYPTO, ASan"
|
||||
scripts/config.pl full
|
||||
scripts/config.pl unset MBEDTLS_MEMORY_BACKTRACE # too slow for tests
|
||||
scripts/config.pl set MBEDTLS_PSA_CRYPTO_C
|
||||
scripts/config.pl set MBEDTLS_USE_PSA_CRYPTO
|
||||
CC=gcc cmake -D CMAKE_BUILD_TYPE:String=Asan .
|
||||
make
|
||||
|
||||
msg "test: main suites (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
make test
|
||||
|
||||
msg "test: ssl-opt.sh (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
if_build_succeeded tests/ssl-opt.sh
|
||||
|
||||
msg "test: compat.sh default (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
if_build_succeeded tests/compat.sh
|
||||
|
||||
msg "test: compat.sh ssl3 (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
if_build_succeeded env OPENSSL_CMD="$OPENSSL_LEGACY" tests/compat.sh -m 'ssl3'
|
||||
|
||||
msg "test: compat.sh RC4, DES & NULL (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
if_build_succeeded env OPENSSL_CMD="$OPENSSL_LEGACY" GNUTLS_CLI="$GNUTLS_LEGACY_CLI" GNUTLS_SERV="$GNUTLS_LEGACY_SERV" tests/compat.sh -e '3DES\|DES-CBC3' -f 'NULL\|DES\|RC4\|ARCFOUR'
|
||||
|
||||
msg "test: compat.sh ARIA + ChachaPoly (MBEDTLS_USE_PSA_CRYPTO)"
|
||||
if_build_succeeded env OPENSSL_CMD="$OPENSSL_NEXT" tests/compat.sh -e '^$' -f 'ARIA\|CHACHA'
|
||||
}
|
||||
|
||||
component_test_check_params_without_platform () {
|
||||
msg "build+test: MBEDTLS_CHECK_PARAMS without MBEDTLS_PLATFORM_C"
|
||||
scripts/config.pl full # includes CHECK_PARAMS
|
||||
scripts/config.pl unset MBEDTLS_MEMORY_BACKTRACE # too slow for tests
|
||||
scripts/config.pl unset MBEDTLS_MEMORY_BUFFER_ALLOC_C
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_EXIT_ALT
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_TIME_ALT
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_FPRINTF_ALT
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_MEMORY
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_PRINTF_ALT
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_SNPRINTF_ALT
|
||||
scripts/config.pl unset MBEDTLS_ENTROPY_NV_SEED
|
||||
scripts/config.pl unset MBEDTLS_PLATFORM_C
|
||||
make CC=gcc CFLAGS='-Werror -O1' all test
|
||||
}
|
||||
|
||||
component_test_check_params_silent () {
|
||||
msg "build+test: MBEDTLS_CHECK_PARAMS with alternative MBEDTLS_PARAM_FAILED()"
|
||||
scripts/config.pl full # includes CHECK_PARAMS
|
||||
scripts/config.pl unset MBEDTLS_MEMORY_BACKTRACE # too slow for tests
|
||||
sed -i 's/.*\(#define MBEDTLS_PARAM_FAILED( cond )\).*/\1/' "$CONFIG_H"
|
||||
make CC=gcc CFLAGS='-Werror -O1' all test
|
||||
}
|
||||
|
||||
component_test_no_platform () {
|
||||
# Full configuration build, without platform support, file IO and net sockets.
|
||||
# This should catch missing mbedtls_printf definitions, and by disabling file
|
||||
@ -1271,6 +1330,8 @@ pre_initialize_variables
|
||||
pre_parse_command_line "$@"
|
||||
|
||||
pre_check_git
|
||||
pre_check_seedfile
|
||||
|
||||
build_status=0
|
||||
if [ $KEEP_GOING -eq 1 ]; then
|
||||
pre_setup_keep_going
|
||||
|
||||
@ -93,6 +93,9 @@ OPENSSL_CMD="$OPENSSL_LEGACY" \
|
||||
GNUTLS_SERV="$GNUTLS_LEGACY_SERV" \
|
||||
sh compat.sh -e '3DES\|DES-CBC3' -f 'NULL\|DES\|RC4\|ARCFOUR' | \
|
||||
tee -a compat-test-$TEST_OUTPUT
|
||||
OPENSSL_CMD="$OPENSSL_NEXT" \
|
||||
sh compat.sh -e '^$' -f 'ARIA\|CHACHA' | \
|
||||
tee -a compat-test-$TEST_OUTPUT
|
||||
echo
|
||||
|
||||
# Step 3 - Process the coverage report
|
||||
|
||||
@ -184,7 +184,13 @@ BEGIN_CASE_REGEX = r'/\*\s*BEGIN_CASE\s*(?P<depends_on>.*?)\s*\*/'
|
||||
END_CASE_REGEX = r'/\*\s*END_CASE\s*\*/'
|
||||
|
||||
DEPENDENCY_REGEX = r'depends_on:(?P<dependencies>.*)'
|
||||
C_IDENTIFIER_REGEX = r'!?[a-z_][a-z0-9_]*$'
|
||||
C_IDENTIFIER_REGEX = r'!?[a-z_][a-z0-9_]*'
|
||||
CONDITION_OPERATOR_REGEX = r'[!=]=|[<>]=?'
|
||||
# forbid 0ddd which might be accidentally octal or accidentally decimal
|
||||
CONDITION_VALUE_REGEX = r'[-+]?(0x[0-9a-f]+|0|[1-9][0-9]*)'
|
||||
CONDITION_REGEX = r'({})(?:\s*({})\s*({}))?$'.format(C_IDENTIFIER_REGEX,
|
||||
CONDITION_OPERATOR_REGEX,
|
||||
CONDITION_VALUE_REGEX)
|
||||
TEST_FUNCTION_VALIDATION_REGEX = r'\s*void\s+(?P<func_name>\w+)\s*\('
|
||||
INT_CHECK_REGEX = r'int\s+.*'
|
||||
CHAR_CHECK_REGEX = r'char\s*\*\s*.*'
|
||||
@ -383,7 +389,7 @@ def validate_dependency(dependency):
|
||||
:return: input dependency stripped of leading & trailing white spaces.
|
||||
"""
|
||||
dependency = dependency.strip()
|
||||
if not re.match(C_IDENTIFIER_REGEX, dependency, re.I):
|
||||
if not re.match(CONDITION_REGEX, dependency, re.I):
|
||||
raise GeneratorInputError('Invalid dependency %s' % dependency)
|
||||
return dependency
|
||||
|
||||
@ -733,16 +739,27 @@ def gen_dep_check(dep_id, dep):
|
||||
_not, dep = ('!', dep[1:]) if dep[0] == '!' else ('', dep)
|
||||
if not dep:
|
||||
raise GeneratorInputError("Dependency should not be an empty string.")
|
||||
|
||||
dependency = re.match(CONDITION_REGEX, dep, re.I)
|
||||
if not dependency:
|
||||
raise GeneratorInputError('Invalid dependency %s' % dep)
|
||||
|
||||
_defined = '' if dependency.group(2) else 'defined'
|
||||
_cond = dependency.group(2) if dependency.group(2) else ''
|
||||
_value = dependency.group(3) if dependency.group(3) else ''
|
||||
|
||||
dep_check = '''
|
||||
case {id}:
|
||||
{{
|
||||
#if {_not}defined({macro})
|
||||
#if {_not}{_defined}({macro}{_cond}{_value})
|
||||
ret = DEPENDENCY_SUPPORTED;
|
||||
#else
|
||||
ret = DEPENDENCY_NOT_SUPPORTED;
|
||||
#endif
|
||||
}}
|
||||
break;'''.format(_not=_not, macro=dep, id=dep_id)
|
||||
break;'''.format(_not=_not, _defined=_defined,
|
||||
macro=dependency.group(1), id=dep_id,
|
||||
_cond=_cond, _value=_value)
|
||||
return dep_check
|
||||
|
||||
|
||||
|
||||
@ -75,11 +75,10 @@ class TestDataParser(object):
|
||||
:param split_char: Split character
|
||||
:return: List of splits
|
||||
"""
|
||||
split_colon_fn = lambda x: re.sub(r'\\' + split_char, split_char, x)
|
||||
if len(split_char) > 1:
|
||||
raise ValueError('Expected split character. Found string!')
|
||||
out = re.sub(r'(\\.)|' + split_char,
|
||||
lambda m: m.group(1) or '\n', inp_str,
|
||||
len(inp_str)).split('\n')
|
||||
out = map(split_colon_fn, re.split(r'(?<!\\)' + split_char, inp_str))
|
||||
out = [x for x in out if x]
|
||||
return out
|
||||
|
||||
@ -112,8 +111,8 @@ class TestDataParser(object):
|
||||
args = parts[1:]
|
||||
args_count = len(args)
|
||||
if args_count % 2 != 0:
|
||||
raise TestDataParserError("Number of test arguments should "
|
||||
"be even: %s" % line)
|
||||
err_str_fmt = "Number of test arguments({}) should be even: {}"
|
||||
raise TestDataParserError(err_str_fmt.format(args_count, line))
|
||||
grouped_args = [(args[i * 2], args[(i * 2) + 1])
|
||||
for i in range(len(args)/2)]
|
||||
self.tests.append((name, function_name, dependencies,
|
||||
@ -163,6 +162,7 @@ class MbedTlsTest(BaseHostTest):
|
||||
self.tests = []
|
||||
self.test_index = -1
|
||||
self.dep_index = 0
|
||||
self.suite_passed = True
|
||||
self.error_str = dict()
|
||||
self.error_str[self.DEPENDENCY_SUPPORTED] = \
|
||||
'DEPENDENCY_SUPPORTED'
|
||||
@ -293,7 +293,7 @@ class MbedTlsTest(BaseHostTest):
|
||||
name, function_id, dependencies, args = self.tests[self.test_index]
|
||||
self.run_test(name, function_id, dependencies, args)
|
||||
else:
|
||||
self.notify_complete(True)
|
||||
self.notify_complete(self.suite_passed)
|
||||
|
||||
def run_test(self, name, function_id, dependencies, args):
|
||||
"""
|
||||
@ -353,6 +353,8 @@ class MbedTlsTest(BaseHostTest):
|
||||
self.log('{{__testcase_start;%s}}' % name)
|
||||
self.log('{{__testcase_finish;%s;%d;%d}}' % (name, int_val == 0,
|
||||
int_val != 0))
|
||||
if int_val != 0:
|
||||
self.suite_passed = False
|
||||
self.run_next_test()
|
||||
|
||||
@event_callback("F")
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
# seem to be a mechanism to reliably check whether the zeroize calls are being
|
||||
# eliminated by compiler optimizations from within the compiled program. The
|
||||
# problem is that a compiler would typically remove what it considers to be
|
||||
# "unecessary" assignments as part of redundant code elimination. To identify
|
||||
# "unnecessary" assignments as part of redundant code elimination. To identify
|
||||
# such code, the compilar will create some form dependency graph between
|
||||
# reads and writes to variables (among other situations). It will then use this
|
||||
# data structure to remove redundant code that does not have an impact on the
|
||||
|
||||
@ -26,7 +26,7 @@ if cd $( dirname $0 ); then :; else
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# default values, can be overriden by the environment
|
||||
# default values, can be overridden by the environment
|
||||
: ${P_SRV:=../programs/ssl/ssl_server2}
|
||||
: ${P_CLI:=../programs/ssl/ssl_client2}
|
||||
: ${P_PXY:=../programs/test/udp_proxy}
|
||||
@ -689,7 +689,7 @@ run_test() {
|
||||
|
||||
# The filtering in the following two options (-u and -U) do the following
|
||||
# - ignore valgrind output
|
||||
# - filter out everything but lines right after the pattern occurances
|
||||
# - filter out everything but lines right after the pattern occurrences
|
||||
# - keep one of each non-unique line
|
||||
# - count how many lines remain
|
||||
# A line with '--' will remain in the result from previous outputs, so the number of lines in the result will be 1
|
||||
@ -755,16 +755,21 @@ run_test() {
|
||||
run_test_psa() {
|
||||
requires_config_enabled MBEDTLS_USE_PSA_CRYPTO
|
||||
run_test "PSA-supported ciphersuite: $1" \
|
||||
"$P_SRV debug_level=1 force_version=tls1_2" \
|
||||
"$P_CLI debug_level=1 force_version=tls1_2 force_ciphersuite=$1" \
|
||||
"$P_SRV debug_level=2 force_version=tls1_2" \
|
||||
"$P_CLI debug_level=2 force_version=tls1_2 force_ciphersuite=$1" \
|
||||
0 \
|
||||
-c "Successfully setup PSA-based decryption cipher context" \
|
||||
-c "Successfully setup PSA-based encryption cipher context" \
|
||||
-c "PSA calc verify" \
|
||||
-c "calc PSA finished" \
|
||||
-s "Successfully setup PSA-based decryption cipher context" \
|
||||
-s "Successfully setup PSA-based encryption cipher context" \
|
||||
-s "PSA calc verify" \
|
||||
-s "calc PSA finished" \
|
||||
-C "Failed to setup PSA-based cipher context"\
|
||||
-S "Failed to setup PSA-based cipher context"\
|
||||
-s "Protocol is TLSv1.2" \
|
||||
-c "Perform PSA-based computation of digest of ServerKeyExchange" \
|
||||
-S "error" \
|
||||
-C "error"
|
||||
}
|
||||
@ -2802,7 +2807,7 @@ run_test "Authentication: server max_int chain, client default" \
|
||||
key_file=data_files/dir-maxpath/09.key" \
|
||||
"$P_CLI server_name=CA09 ca_file=data_files/dir-maxpath/00.crt" \
|
||||
0 \
|
||||
-C "X509 - A fatal error occured"
|
||||
-C "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: server max_int+1 chain, client default" \
|
||||
@ -2810,7 +2815,7 @@ run_test "Authentication: server max_int+1 chain, client default" \
|
||||
key_file=data_files/dir-maxpath/10.key" \
|
||||
"$P_CLI server_name=CA10 ca_file=data_files/dir-maxpath/00.crt" \
|
||||
1 \
|
||||
-c "X509 - A fatal error occured"
|
||||
-c "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: server max_int+1 chain, client optional" \
|
||||
@ -2819,7 +2824,7 @@ run_test "Authentication: server max_int+1 chain, client optional" \
|
||||
"$P_CLI server_name=CA10 ca_file=data_files/dir-maxpath/00.crt \
|
||||
auth_mode=optional" \
|
||||
1 \
|
||||
-c "X509 - A fatal error occured"
|
||||
-c "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: server max_int+1 chain, client none" \
|
||||
@ -2828,7 +2833,7 @@ run_test "Authentication: server max_int+1 chain, client none" \
|
||||
"$P_CLI server_name=CA10 ca_file=data_files/dir-maxpath/00.crt \
|
||||
auth_mode=none" \
|
||||
0 \
|
||||
-C "X509 - A fatal error occured"
|
||||
-C "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: client max_int+1 chain, server default" \
|
||||
@ -2836,7 +2841,7 @@ run_test "Authentication: client max_int+1 chain, server default" \
|
||||
"$P_CLI crt_file=data_files/dir-maxpath/c10.pem \
|
||||
key_file=data_files/dir-maxpath/10.key" \
|
||||
0 \
|
||||
-S "X509 - A fatal error occured"
|
||||
-S "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: client max_int+1 chain, server optional" \
|
||||
@ -2844,7 +2849,7 @@ run_test "Authentication: client max_int+1 chain, server optional" \
|
||||
"$P_CLI crt_file=data_files/dir-maxpath/c10.pem \
|
||||
key_file=data_files/dir-maxpath/10.key" \
|
||||
1 \
|
||||
-s "X509 - A fatal error occured"
|
||||
-s "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: client max_int+1 chain, server required" \
|
||||
@ -2852,7 +2857,7 @@ run_test "Authentication: client max_int+1 chain, server required" \
|
||||
"$P_CLI crt_file=data_files/dir-maxpath/c10.pem \
|
||||
key_file=data_files/dir-maxpath/10.key" \
|
||||
1 \
|
||||
-s "X509 - A fatal error occured"
|
||||
-s "X509 - A fatal error occurred"
|
||||
|
||||
requires_full_size_output_buffer
|
||||
run_test "Authentication: client max_int chain, server required" \
|
||||
@ -2860,7 +2865,7 @@ run_test "Authentication: client max_int chain, server required" \
|
||||
"$P_CLI crt_file=data_files/dir-maxpath/c09.pem \
|
||||
key_file=data_files/dir-maxpath/09.key" \
|
||||
0 \
|
||||
-S "X509 - A fatal error occured"
|
||||
-S "X509 - A fatal error occurred"
|
||||
|
||||
# Tests for CA list in CertificateRequest messages
|
||||
|
||||
@ -7602,6 +7607,11 @@ run_test "DTLS proxy: 3d, gnutls server" \
|
||||
-s "Extra-header:" \
|
||||
-c "Extra-header:"
|
||||
|
||||
# The next two test are disabled because they tend to trigger a bug in the
|
||||
# version of GnuTLS that's currently installed on our CI. The bug occurs when
|
||||
# different fragments of the same handshake message are received out-of-order
|
||||
# by GnuTLS and results in a timeout. It's been fixed in GnuTLS 3.5.2.
|
||||
skip_next_test
|
||||
requires_gnutls
|
||||
client_needs_more_time 8
|
||||
not_with_valgrind # risk of non-mbedtls peer timing out
|
||||
@ -7613,6 +7623,7 @@ run_test "DTLS proxy: 3d, gnutls server, fragmentation" \
|
||||
-s "Extra-header:" \
|
||||
-c "Extra-header:"
|
||||
|
||||
skip_next_test
|
||||
requires_gnutls
|
||||
client_needs_more_time 8
|
||||
not_with_valgrind # risk of non-mbedtls peer timing out
|
||||
|
||||
@ -23,6 +23,11 @@
|
||||
#include "mbedtls/memory_buffer_alloc.h"
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CHECK_PARAMS)
|
||||
#include "mbedtls/platform_util.h"
|
||||
#include <setjmp.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <basetsd.h>
|
||||
typedef UINT8 uint8_t;
|
||||
@ -65,29 +70,50 @@ typedef struct data_tag
|
||||
#define DISPATCH_UNSUPPORTED_SUITE -5 /* Test suite not supported by the
|
||||
build */
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PARAMFAIL_TESTSTATE_IDLE = 0, /* No parameter failure call test */
|
||||
PARAMFAIL_TESTSTATE_PENDING, /* Test call to the parameter failure
|
||||
* is pending */
|
||||
PARAMFAIL_TESTSTATE_CALLED /* The test call to the parameter
|
||||
* failure function has been made */
|
||||
} paramfail_test_state_t;
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Macros */
|
||||
|
||||
/** Evaluate an expression and fail the test case if it is false.
|
||||
/**
|
||||
* \brief This macro tests the expression passed to it as a test step or
|
||||
* individual test in a test case.
|
||||
*
|
||||
* Failing the test means:
|
||||
* - Mark this test case as failed.
|
||||
* - Print a message identifying the failure.
|
||||
* - Jump to the \c exit label.
|
||||
* It allows a library function to return a value and return an error
|
||||
* code that can be tested.
|
||||
*
|
||||
* This macro expands to an instruction, not an expression.
|
||||
* It may jump to the \c exit label.
|
||||
* When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
|
||||
* callback, MBEDTLS_PARAM_FAILED(), will be assumed to be a test
|
||||
* failure.
|
||||
*
|
||||
* \param TEST The expression to evaluate.
|
||||
* This macro is not suitable for negative parameter validation tests,
|
||||
* as it assumes the test step will not create an error.
|
||||
*
|
||||
* Failing the test means:
|
||||
* - Mark this test case as failed.
|
||||
* - Print a message identifying the failure.
|
||||
* - Jump to the \c exit label.
|
||||
*
|
||||
* This macro expands to an instruction, not an expression.
|
||||
* It may jump to the \c exit label.
|
||||
*
|
||||
* \param TEST The test expression to be tested.
|
||||
*/
|
||||
#define TEST_ASSERT( TEST ) \
|
||||
do { \
|
||||
if( ! (TEST) ) \
|
||||
{ \
|
||||
test_fail( #TEST, __LINE__, __FILE__ ); \
|
||||
goto exit; \
|
||||
} \
|
||||
#define TEST_ASSERT( TEST ) \
|
||||
do { \
|
||||
if( ! (TEST) ) \
|
||||
{ \
|
||||
test_fail( #TEST, __LINE__, __FILE__ ); \
|
||||
goto exit; \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
/** Evaluate two expressions and fail the test case if they have different
|
||||
@ -161,6 +187,105 @@ typedef struct data_tag
|
||||
} \
|
||||
while( 0 )
|
||||
|
||||
#if defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
|
||||
/**
|
||||
* \brief This macro tests the statement passed to it as a test step or
|
||||
* individual test in a test case. The macro assumes the test will fail
|
||||
* and will generate an error.
|
||||
*
|
||||
* It allows a library function to return a value and tests the return
|
||||
* code on return to confirm the given error code was returned.
|
||||
*
|
||||
* When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
|
||||
* callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
|
||||
* expected failure, and the test will pass.
|
||||
*
|
||||
* This macro is intended for negative parameter validation tests,
|
||||
* where the failing function may return an error value or call
|
||||
* MBEDTLS_PARAM_FAILED() to indicate the error.
|
||||
*
|
||||
* \param PARAM_ERROR_VALUE The expected error code.
|
||||
*
|
||||
* \param TEST The test expression to be tested.
|
||||
*/
|
||||
#define TEST_INVALID_PARAM_RET( PARAM_ERR_VALUE, TEST ) \
|
||||
do { \
|
||||
test_info.paramfail_test_state = PARAMFAIL_TESTSTATE_PENDING; \
|
||||
if( (TEST) != (PARAM_ERR_VALUE) || \
|
||||
test_info.paramfail_test_state != PARAMFAIL_TESTSTATE_CALLED ) \
|
||||
{ \
|
||||
test_fail( #TEST, __LINE__, __FILE__ ); \
|
||||
goto exit; \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
/**
|
||||
* \brief This macro tests the statement passed to it as a test step or
|
||||
* individual test in a test case. The macro assumes the test will fail
|
||||
* and will generate an error.
|
||||
*
|
||||
* It assumes the library function under test cannot return a value and
|
||||
* assumes errors can only be indicated byt calls to
|
||||
* MBEDTLS_PARAM_FAILED().
|
||||
*
|
||||
* When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
|
||||
* callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
|
||||
* expected failure. If MBEDTLS_CHECK_PARAMS is not enabled, no test
|
||||
* can be made.
|
||||
*
|
||||
* This macro is intended for negative parameter validation tests,
|
||||
* where the failing function can only return an error by calling
|
||||
* MBEDTLS_PARAM_FAILED() to indicate the error.
|
||||
*
|
||||
* \param TEST The test expression to be tested.
|
||||
*/
|
||||
#define TEST_INVALID_PARAM( TEST ) \
|
||||
do { \
|
||||
memcpy(jmp_tmp, param_fail_jmp, sizeof(jmp_buf)); \
|
||||
if( setjmp( param_fail_jmp ) == 0 ) \
|
||||
{ \
|
||||
TEST; \
|
||||
test_fail( #TEST, __LINE__, __FILE__ ); \
|
||||
goto exit; \
|
||||
} \
|
||||
memcpy(param_fail_jmp, jmp_tmp, sizeof(jmp_buf)); \
|
||||
} while( 0 )
|
||||
#endif /* MBEDTLS_CHECK_PARAMS && !MBEDTLS_PARAM_FAILED_ALT */
|
||||
|
||||
/**
|
||||
* \brief This macro tests the statement passed to it as a test step or
|
||||
* individual test in a test case. The macro assumes the test will not fail.
|
||||
*
|
||||
* It assumes the library function under test cannot return a value and
|
||||
* assumes errors can only be indicated by calls to
|
||||
* MBEDTLS_PARAM_FAILED().
|
||||
*
|
||||
* When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
|
||||
* callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
|
||||
* expected failure. If MBEDTLS_CHECK_PARAMS is not enabled, no test
|
||||
* can be made.
|
||||
*
|
||||
* This macro is intended to test that functions returning void
|
||||
* accept all of the parameter values they're supposed to accept - eg
|
||||
* that they don't call MBEDTLS_PARAM_FAILED() when a parameter
|
||||
* that's allowed to be NULL happens to be NULL.
|
||||
*
|
||||
* Note: for functions that return something other that void,
|
||||
* checking that they accept all the parameters they're supposed to
|
||||
* accept is best done by using TEST_ASSERT() and checking the return
|
||||
* value as well.
|
||||
*
|
||||
* Note: this macro is available even when #MBEDTLS_CHECK_PARAMS is
|
||||
* disabled, as it makes sense to check that the functions accept all
|
||||
* legal values even if this option is disabled - only in that case,
|
||||
* the test is more about whether the function segfaults than about
|
||||
* whether it invokes MBEDTLS_PARAM_FAILED().
|
||||
*
|
||||
* \param TEST The test expression to be tested.
|
||||
*/
|
||||
#define TEST_VALID_PARAM( TEST ) \
|
||||
TEST_ASSERT( ( TEST, 1 ) );
|
||||
|
||||
#define assert(a) if( !( a ) ) \
|
||||
{ \
|
||||
mbedtls_fprintf( stderr, "Assertion Failed at %s:%d - %s\n", \
|
||||
@ -247,9 +372,9 @@ typedef struct data_tag
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Global variables */
|
||||
|
||||
|
||||
static struct
|
||||
{
|
||||
paramfail_test_state_t paramfail_test_state;
|
||||
int failed;
|
||||
const char *test;
|
||||
const char *filename;
|
||||
@ -261,6 +386,11 @@ test_info;
|
||||
mbedtls_platform_context platform_ctx;
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CHECK_PARAMS)
|
||||
jmp_buf param_fail_jmp;
|
||||
jmp_buf jmp_tmp;
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Helper flags for complex dependencies */
|
||||
|
||||
@ -278,6 +408,15 @@ mbedtls_platform_context platform_ctx;
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Helper Functions */
|
||||
|
||||
static void test_fail( const char *test, int line_no, const char* filename )
|
||||
{
|
||||
test_info.failed = 1;
|
||||
test_info.test = test;
|
||||
test_info.line_no = line_no;
|
||||
test_info.filename = filename;
|
||||
}
|
||||
|
||||
static int platform_setup()
|
||||
{
|
||||
int ret = 0;
|
||||
@ -294,6 +433,30 @@ static void platform_teardown()
|
||||
#endif /* MBEDTLS_PLATFORM_C */
|
||||
}
|
||||
|
||||
#if defined(MBEDTLS_CHECK_PARAMS)
|
||||
void mbedtls_param_failed( const char *failure_condition,
|
||||
const char *file,
|
||||
int line )
|
||||
{
|
||||
/* If we are testing the callback function... */
|
||||
if( test_info.paramfail_test_state == PARAMFAIL_TESTSTATE_PENDING )
|
||||
{
|
||||
test_info.paramfail_test_state = PARAMFAIL_TESTSTATE_CALLED;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* ...else we treat this as an error */
|
||||
|
||||
/* Record the location of the failure, but not as a failure yet, in case
|
||||
* it was part of the test */
|
||||
test_fail( failure_condition, line, file );
|
||||
test_info.failed = 0;
|
||||
|
||||
longjmp( param_fail_jmp, 1 );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
|
||||
static int redirect_output( FILE** out_stream, const char* path )
|
||||
{
|
||||
@ -310,6 +473,7 @@ static int redirect_output( FILE** out_stream, const char* path )
|
||||
|
||||
if( *out_stream == NULL )
|
||||
{
|
||||
close( stdout_fd );
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -582,25 +746,17 @@ static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
static void test_fail( const char *test, int line_no, const char* filename )
|
||||
{
|
||||
test_info.failed = 1;
|
||||
test_info.test = test;
|
||||
test_info.line_no = line_no;
|
||||
test_info.filename = filename;
|
||||
}
|
||||
|
||||
int hexcmp( uint8_t * a, uint8_t * b, uint32_t a_len, uint32_t b_len )
|
||||
{
|
||||
int ret = 0;
|
||||
uint32_t i = 0;
|
||||
|
||||
if ( a_len != b_len )
|
||||
if( a_len != b_len )
|
||||
return( -1 );
|
||||
|
||||
for( i = 0; i < a_len; i++ )
|
||||
{
|
||||
if ( a[i] != b[i] )
|
||||
if( a[i] != b[i] )
|
||||
{
|
||||
ret = -1;
|
||||
break;
|
||||
@ -608,4 +764,3 @@ int hexcmp( uint8_t * a, uint8_t * b, uint32_t a_len, uint32_t b_len )
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -546,6 +546,7 @@ int execute_tests( int argc , const char ** argv )
|
||||
if( unmet_dep_count == 0 )
|
||||
{
|
||||
test_info.failed = 0;
|
||||
test_info.paramfail_test_state = PARAMFAIL_TESTSTATE_IDLE;
|
||||
|
||||
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
|
||||
/* Suppress all output from the library unless we're verbose
|
||||
|
||||
@ -137,9 +137,39 @@ $dispatch_code
|
||||
#line $line_no "suites/main_test.function"
|
||||
};
|
||||
|
||||
/**
|
||||
* \brief Execute the test function.
|
||||
*
|
||||
* This is a wrapper function around the test function execution
|
||||
* to allow the setjmp() call used to catch any calls to the
|
||||
* parameter failure callback, to be used. Calls to setjmp()
|
||||
* can invalidate the state of any local auto variables.
|
||||
*
|
||||
* \param fp Function pointer to the test function
|
||||
* \param params Parameters to pass
|
||||
*
|
||||
*/
|
||||
void execute_function_ptr(TestWrapper_t fp, void **params)
|
||||
{
|
||||
#if defined(MBEDTLS_CHECK_PARAMS)
|
||||
if ( setjmp( param_fail_jmp ) == 0 )
|
||||
{
|
||||
fp( params );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Unexpected parameter validation error */
|
||||
test_info.failed = 1;
|
||||
}
|
||||
|
||||
memset( param_fail_jmp, 0, sizeof(jmp_buf) );
|
||||
#else
|
||||
fp( params );
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Dispatches test functions based on function index.
|
||||
* \brief Dispatches test functions based on function index.
|
||||
*
|
||||
* \param exp_id Test function index.
|
||||
*
|
||||
@ -156,7 +186,7 @@ int dispatch_test( int func_idx, void ** params )
|
||||
{
|
||||
fp = test_funcs[func_idx];
|
||||
if ( fp )
|
||||
fp( params );
|
||||
execute_function_ptr(fp, params);
|
||||
else
|
||||
ret = DISPATCH_UNSUPPORTED_SUITE;
|
||||
}
|
||||
@ -225,20 +255,6 @@ int main( int argc, const char *argv[] )
|
||||
return( -1 );
|
||||
}
|
||||
|
||||
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
||||
{
|
||||
psa_status_t status;
|
||||
status = psa_crypto_init();
|
||||
if( status != PSA_SUCCESS )
|
||||
{
|
||||
mbedtls_fprintf( stderr,
|
||||
"FATAL: Failed to initialize PSA Crypto - error %d\n",
|
||||
status );
|
||||
return( -1 );
|
||||
}
|
||||
}
|
||||
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
||||
|
||||
ret = execute_tests( argc, argv );
|
||||
platform_teardown();
|
||||
return( ret );
|
||||
|
||||
@ -15,8 +15,8 @@ void aes_encrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
mbedtls_aes_context ctx;
|
||||
|
||||
memset(output, 0x00, 100);
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
|
||||
if( setkey_result == 0 )
|
||||
@ -39,8 +39,8 @@ void aes_decrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
mbedtls_aes_context ctx;
|
||||
|
||||
memset(output, 0x00, 100);
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
|
||||
if( setkey_result == 0 )
|
||||
@ -64,8 +64,8 @@ void aes_encrypt_cbc( data_t * key_str, data_t * iv_str,
|
||||
mbedtls_aes_context ctx;
|
||||
|
||||
memset(output, 0x00, 100);
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
|
||||
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
|
||||
@ -91,7 +91,6 @@ void aes_decrypt_cbc( data_t * key_str, data_t * iv_str,
|
||||
memset(output, 0x00, 100);
|
||||
mbedtls_aes_init( &ctx );
|
||||
|
||||
|
||||
mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 );
|
||||
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
|
||||
if( cbc_result == 0)
|
||||
@ -195,8 +194,8 @@ exit:
|
||||
void aes_crypt_xts_size( int size, int retval )
|
||||
{
|
||||
mbedtls_aes_xts_context ctx;
|
||||
const unsigned char *src = NULL;
|
||||
unsigned char *output = NULL;
|
||||
const unsigned char src[16] = { 0 };
|
||||
unsigned char output[16];
|
||||
unsigned char data_unit[16];
|
||||
size_t length = size;
|
||||
|
||||
@ -204,10 +203,8 @@ void aes_crypt_xts_size( int size, int retval )
|
||||
memset( data_unit, 0x00, sizeof( data_unit ) );
|
||||
|
||||
|
||||
/* Note that this function will most likely crash on failure, as NULL
|
||||
* parameters will be used. In the passing case, the length check in
|
||||
* mbedtls_aes_crypt_xts() will prevent any accesses to parameters by
|
||||
* exiting the function early. */
|
||||
/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
|
||||
* otherwise we wouldn't get to the size check we're interested in. */
|
||||
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -216,7 +213,7 @@ void aes_crypt_xts_size( int size, int retval )
|
||||
void aes_crypt_xts_keysize( int size, int retval )
|
||||
{
|
||||
mbedtls_aes_xts_context ctx;
|
||||
const unsigned char *key = NULL;
|
||||
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
size_t key_len = size;
|
||||
|
||||
mbedtls_aes_xts_init( &ctx );
|
||||
@ -372,6 +369,259 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void aes_check_params( )
|
||||
{
|
||||
mbedtls_aes_context aes_ctx;
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
mbedtls_aes_xts_context xts_ctx;
|
||||
#endif
|
||||
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
const unsigned char in[16] = { 0 };
|
||||
unsigned char out[16];
|
||||
size_t size;
|
||||
const int valid_mode = MBEDTLS_AES_ENCRYPT;
|
||||
const int invalid_mode = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_aes_init( NULL ) );
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM( mbedtls_aes_xts_init( NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_enc( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_enc( &aes_ctx, NULL, 128 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_dec( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_dec( &aes_ctx, NULL, 128 ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_enc( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_enc( &xts_ctx, NULL, 128 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_dec( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_dec( &xts_ctx, NULL, 128 ) );
|
||||
#endif
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( NULL,
|
||||
valid_mode, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
invalid_mode, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
valid_mode, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
valid_mode, in, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( NULL,
|
||||
valid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( NULL,
|
||||
valid_mode, 16,
|
||||
in, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
invalid_mode, 16,
|
||||
in, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
in, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
in, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_XTS */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( NULL,
|
||||
valid_mode, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, out, in, NULL ) );
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( NULL,
|
||||
valid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_OFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( NULL, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
NULL, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_OFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( NULL, 16, &size, out,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, NULL, out,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, NULL,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void aes_misc_params( )
|
||||
{
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
|
||||
defined(MBEDTLS_CIPHER_MODE_XTS) || \
|
||||
defined(MBEDTLS_CIPHER_MODE_CFB) || \
|
||||
defined(MBEDTLS_CIPHER_MODE_OFB)
|
||||
mbedtls_aes_context aes_ctx;
|
||||
const unsigned char in[16] = { 0 };
|
||||
unsigned char out[16];
|
||||
#endif
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
mbedtls_aes_xts_context xts_ctx;
|
||||
#endif
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB) || \
|
||||
defined(MBEDTLS_CIPHER_MODE_OFB)
|
||||
size_t size;
|
||||
#endif
|
||||
|
||||
/* These calls accept NULL */
|
||||
TEST_VALID_PARAM( mbedtls_aes_free( NULL ) );
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_VALID_PARAM( mbedtls_aes_xts_free( NULL ) );
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
|
||||
15,
|
||||
out, in, out )
|
||||
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
|
||||
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
|
||||
17,
|
||||
out, in, out )
|
||||
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
|
||||
15,
|
||||
in, in, out )
|
||||
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
|
||||
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
|
||||
(1 << 24) + 1,
|
||||
in, in, out )
|
||||
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
size = 16;
|
||||
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
|
||||
&size, out, in, out )
|
||||
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_OFB)
|
||||
size = 16;
|
||||
TEST_ASSERT( mbedtls_aes_crypt_ofb( &aes_ctx, 16, &size, out, in, out )
|
||||
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
|
||||
#endif
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void aes_selftest( )
|
||||
{
|
||||
|
||||
@ -10,6 +10,12 @@ aes_encrypt_cbc:"000000000000000000000000000000000000000000000000000000000000000
|
||||
AES-256-CBC Decrypt (Invalid input length)
|
||||
aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c74":"":MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH
|
||||
|
||||
AES - Optional Parameter Validation (MBEDTLS_CHECK_PARAMS)
|
||||
aes_check_params:
|
||||
|
||||
AES - Mandatory Parameter Validation and Valid Parameters
|
||||
aes_misc_params:
|
||||
|
||||
AES Selftest
|
||||
depends_on:MBEDTLS_SELF_TEST
|
||||
aes_selftest:
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
ARIA - Valid parameters
|
||||
aria_valid_param:
|
||||
|
||||
ARIA - Invalid parameters
|
||||
aria_invalid_param:
|
||||
|
||||
ARIA-128-ECB Encrypt - RFC 5794
|
||||
aria_encrypt_ecb:"000102030405060708090a0b0c0d0e0f":"00112233445566778899aabbccddeeff":"d718fbd6ab644c739da95f3be6451778":0
|
||||
|
||||
|
||||
@ -16,6 +16,195 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void aria_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_aria_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void aria_invalid_param( )
|
||||
{
|
||||
mbedtls_aria_context ctx;
|
||||
unsigned char key[128 / 8] = { 0 };
|
||||
unsigned char input[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
size_t iv_off = 0;
|
||||
|
||||
((void) iv_off);
|
||||
((void) iv);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_aria_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_enc( NULL, key,
|
||||
sizeof( key ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_enc( &ctx, NULL,
|
||||
sizeof( key ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_dec( NULL, key,
|
||||
sizeof( key ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_dec( &ctx, NULL,
|
||||
sizeof( key ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( NULL, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( &ctx, NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( &ctx, input, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( NULL,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
42 /* invalid mode */,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( NULL,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
42, /* invalid mode */
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( NULL,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
NULL,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void aria_encrypt_ecb( char *hex_key_string, char *hex_src_string,
|
||||
char *hex_dst_string, int setkey_result )
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
BLOWFISH - Valid parameters
|
||||
blowfish_valid_param:
|
||||
|
||||
BLOWFISH - Invalid parameters
|
||||
blowfish_invalid_param:
|
||||
|
||||
BLOWFISH-ECB Encrypt SSLeay reference #1
|
||||
blowfish_encrypt_ecb:"0000000000000000":"0000000000000000":"4ef997456198dd78":0
|
||||
|
||||
@ -203,13 +209,13 @@ BLOWFISH-ECB Decrypt SSLeay reference #34
|
||||
blowfish_decrypt_ecb:"fedcba9876543210":"6b5c5a9c5d9e0a5a":"ffffffffffffffff":0
|
||||
|
||||
BLOWFISH-SETKEY Setkey SSLeay reference #1
|
||||
blowfish_encrypt_ecb:"f0":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH
|
||||
blowfish_encrypt_ecb:"f0":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA
|
||||
|
||||
BLOWFISH-SETKEY Setkey SSLeay reference #2
|
||||
blowfish_encrypt_ecb:"f0e1":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH
|
||||
blowfish_encrypt_ecb:"f0e1":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA
|
||||
|
||||
BLOWFISH-SETKEY Setkey SSLeay reference #3
|
||||
blowfish_encrypt_ecb:"f0e1d2":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH
|
||||
blowfish_encrypt_ecb:"f0e1d2":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA
|
||||
|
||||
BLOWFISH-SETKEY Setkey SSLeay reference #4
|
||||
blowfish_encrypt_ecb:"f0e1d2c3":"fedcba9876543210":"be1e639408640f05":0
|
||||
@ -281,7 +287,7 @@ BLOWFISH-SETKEY Setkey 448 bits
|
||||
blowfish_encrypt_ecb:"f0e1d2c3b4a5968778695a4b3c2d1e0f00112233445566778899aabbccddeeff0123456789abcdef0102030405060708090a0b0c0d0e0fff":"fedcba9876543210":"2fb3ab7f0ee91b69":0
|
||||
|
||||
BLOWFISH-SETKEY Setkey 456 bits
|
||||
blowfish_encrypt_ecb:"f0e1d2c3b4a5968778695a4b3c2d1e0f00112233445566778899aabbccddeeff0123456789abcdef0102030405060708090a0b0c0d0e0fffff":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH
|
||||
blowfish_encrypt_ecb:"f0e1d2c3b4a5968778695a4b3c2d1e0f00112233445566778899aabbccddeeff0123456789abcdef0102030405060708090a0b0c0d0e0fffff":"fedcba9876543210":"":MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA
|
||||
|
||||
BLOWFISH-CBC Encrypt
|
||||
blowfish_encrypt_cbc:"0123456789ABCDEFF0E1D2C3B4A59687":"FEDCBA9876543210":"37363534333231204E6F77206973207468652074696D6520666F722000000000":"6b77b4d63006dee605b156e27403979358deb9e7154616d959f1652bd5ff92cc":0
|
||||
|
||||
@ -7,6 +7,164 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void blowfish_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void blowfish_invalid_param( )
|
||||
{
|
||||
mbedtls_blowfish_context ctx;
|
||||
unsigned char buf[16] = { 0 };
|
||||
size_t const valid_keylength = sizeof( buf ) * 8;
|
||||
size_t valid_mode = MBEDTLS_BLOWFISH_ENCRYPT;
|
||||
size_t invalid_mode = 42;
|
||||
size_t off;
|
||||
((void) off);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_blowfish_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_setkey( NULL,
|
||||
buf,
|
||||
valid_keylength ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_setkey( &ctx,
|
||||
NULL,
|
||||
valid_keylength ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( NULL,
|
||||
valid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
invalid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
buf, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( NULL,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void blowfish_encrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
data_t * hex_dst_string, int setkey_result )
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
Camellia - Valid parameters
|
||||
camellia_valid_param:
|
||||
|
||||
Camellia - Invalid parameters
|
||||
camellia_invalid_param:
|
||||
|
||||
Camellia-128-ECB Encrypt RFC3713 #1
|
||||
camellia_encrypt_ecb:"0123456789abcdeffedcba9876543210":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":0
|
||||
|
||||
@ -185,10 +191,10 @@ depends_on:MBEDTLS_CIPHER_MODE_CFB
|
||||
camellia_decrypt_cfb128:"603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4":"555FC3F34BDD2D54C62D9E3BF338C1C4":"F69F2445DF4F9B17AD2B417BE66C3710":"5953ADCE14DB8C7F39F1BD39F359BFFA"
|
||||
|
||||
Camellia-ECB Encrypt (Invalid key length)
|
||||
camellia_encrypt_ecb:"0123456789abcdeffedcba98765432":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH
|
||||
camellia_encrypt_ecb:"0123456789abcdeffedcba98765432":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA
|
||||
|
||||
Camellia-ECB Decrypt (Invalid key length)
|
||||
camellia_decrypt_ecb:"0123456789abcdeffedcba98765432":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH
|
||||
camellia_decrypt_ecb:"0123456789abcdeffedcba98765432":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA
|
||||
|
||||
Camellia-256-CBC Encrypt (Invalid input length)
|
||||
camellia_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffe000000000000000":"":MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH
|
||||
|
||||
@ -7,6 +7,172 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void camellia_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_camellia_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void camellia_invalid_param( )
|
||||
{
|
||||
mbedtls_camellia_context ctx;
|
||||
unsigned char buf[16] = { 0 };
|
||||
const size_t valid_keybits = 128;
|
||||
const int invalid_mode = 42;
|
||||
const int valid_mode = MBEDTLS_CAMELLIA_ENCRYPT;
|
||||
size_t off;
|
||||
((void) off);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_camellia_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_enc( NULL,
|
||||
buf,
|
||||
valid_keybits ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_enc( &ctx,
|
||||
NULL,
|
||||
valid_keybits ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_dec( NULL,
|
||||
buf,
|
||||
valid_keybits ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_dec( &ctx,
|
||||
NULL,
|
||||
valid_keybits ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( NULL,
|
||||
valid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
invalid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
buf, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( NULL,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void camellia_encrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
data_t * hex_dst_string, int setkey_result )
|
||||
|
||||
@ -1,6 +1,12 @@
|
||||
CCM self test
|
||||
mbedtls_ccm_self_test:
|
||||
|
||||
CCM - Invalid parameters
|
||||
ccm_invalid_param:
|
||||
|
||||
CCM - Valid parameters
|
||||
ccm_valid_param:
|
||||
|
||||
CCM init #1 AES-128: OK
|
||||
depends_on:MBEDTLS_AES_C
|
||||
mbedtls_ccm_setkey:MBEDTLS_CIPHER_ID_AES:128:0
|
||||
@ -35,7 +41,8 @@ ccm_lengths:5:10:5:18:MBEDTLS_ERR_CCM_BAD_INPUT
|
||||
CCM lengths #6 tag length not even
|
||||
ccm_lengths:5:10:5:7:MBEDTLS_ERR_CCM_BAD_INPUT
|
||||
|
||||
CCM lenghts #7 AD too long (2^16 - 2^8 + 1)
|
||||
CCM lengths #7 AD too long (2^16 - 2^8 + 1)
|
||||
depends_on:!MBEDTLS_CCM_ALT
|
||||
ccm_lengths:5:10:65281:8:MBEDTLS_ERR_CCM_BAD_INPUT
|
||||
|
||||
CCM lengths #8 msg too long for this IV length (2^16, q = 2)
|
||||
|
||||
@ -326,3 +326,216 @@ exit:
|
||||
mbedtls_ccm_free( &ctx );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ccm_invalid_param( )
|
||||
{
|
||||
struct mbedtls_ccm_context ctx;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
|
||||
int valid_len = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_len * 8;
|
||||
|
||||
mbedtls_ccm_init( &ctx );
|
||||
|
||||
/* mbedtls_ccm_init() */
|
||||
TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
|
||||
|
||||
/* mbedtls_ccm_setkey() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
|
||||
|
||||
/* mbedtls_ccm_encrypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_star_encrypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_star_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
exit:
|
||||
mbedtls_ccm_free( &ctx );
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ccm_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
@ -82,7 +82,7 @@ void chacha20_crypt( char *hex_key_string,
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void chacha20_bad_params()
|
||||
{
|
||||
unsigned char key[32];
|
||||
@ -93,42 +93,38 @@ void chacha20_bad_params()
|
||||
size_t len = sizeof( src );
|
||||
mbedtls_chacha20_context ctx;
|
||||
|
||||
mbedtls_chacha20_init( NULL );
|
||||
mbedtls_chacha20_free( NULL );
|
||||
TEST_INVALID_PARAM( mbedtls_chacha20_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_chacha20_free( NULL ) );
|
||||
|
||||
mbedtls_chacha20_init( &ctx );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_setkey( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_setkey( &ctx, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chacha20_setkey( NULL, key )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_setkey( &ctx, NULL )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_starts( NULL, nonce, counter ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_starts( &ctx, NULL, counter ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chacha20_starts( NULL, nonce, counter )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_starts( &ctx, NULL, counter )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( NULL, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( &ctx, len, NULL, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( &ctx, len, src, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chacha20_update( NULL, 0, src, dst )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_update( &ctx, len, NULL, dst )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_update( &ctx, len, src, NULL )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_update( &ctx, 0, NULL, NULL )
|
||||
== 0 );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( NULL, nonce, counter, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, NULL, counter, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, nonce, counter, len, NULL, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, nonce, counter, len, src, NULL ) );
|
||||
|
||||
mbedtls_chacha20_free( &ctx );
|
||||
exit:
|
||||
return;
|
||||
|
||||
TEST_ASSERT( mbedtls_chacha20_crypt( NULL, nonce, counter, 0, src, dst )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_crypt( key, NULL, counter, 0, src, dst )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_crypt( key, nonce, counter, len, NULL, dst )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_crypt( key, nonce, counter, len, src, NULL )
|
||||
== MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chacha20_crypt( key, nonce, counter, 0, NULL, NULL )
|
||||
== 0 );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
|
||||
@ -118,7 +118,7 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void chachapoly_bad_params()
|
||||
{
|
||||
unsigned char key[32];
|
||||
@ -138,124 +138,114 @@ void chachapoly_bad_params()
|
||||
memset( output, 0x00, sizeof( output ) );
|
||||
memset( mac, 0x00, sizeof( mac ) );
|
||||
|
||||
mbedtls_chachapoly_init( NULL );
|
||||
mbedtls_chachapoly_free( NULL );
|
||||
TEST_INVALID_PARAM( mbedtls_chachapoly_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_chachapoly_free( NULL ) );
|
||||
|
||||
mbedtls_chachapoly_init( &ctx );
|
||||
/* setkey */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_setkey( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_setkey( &ctx, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_setkey( NULL, key )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_setkey( &ctx, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( NULL,
|
||||
/* encrypt_and_tag */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( NULL,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
input, output, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, NULL,
|
||||
aad, 0,
|
||||
input, output, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, nonce,
|
||||
NULL, aad_len,
|
||||
input, output, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
NULL, output, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
NULL, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
input, NULL, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input, NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
input, output, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
input, output, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( NULL,
|
||||
/* auth_decrypt */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( NULL,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
mac, input, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, NULL,
|
||||
aad, 0,
|
||||
mac, input, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, nonce,
|
||||
NULL, aad_len,
|
||||
mac, input, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
NULL, input, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
NULL, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
mac, NULL, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
mac, NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
mac, input, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
mac, input, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, nonce,
|
||||
aad, aad_len,
|
||||
NULL, NULL, mac )
|
||||
== 0 );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, nonce,
|
||||
aad, aad_len,
|
||||
mac, NULL, NULL )
|
||||
== 0 );
|
||||
/* starts */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_starts( NULL, nonce,
|
||||
MBEDTLS_CHACHAPOLY_ENCRYPT ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_starts( &ctx, NULL,
|
||||
MBEDTLS_CHACHAPOLY_ENCRYPT ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input_len, nonce,
|
||||
NULL, 0,
|
||||
input, output, mac )
|
||||
== 0 );
|
||||
TEST_ASSERT( mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
input_len, nonce,
|
||||
NULL, 0,
|
||||
mac, input, output )
|
||||
== 0 );
|
||||
/* update_aad */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update_aad( NULL, aad,
|
||||
aad_len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update_aad( &ctx, NULL,
|
||||
aad_len ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_starts( NULL, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_starts( &ctx, NULL, MBEDTLS_CHACHAPOLY_ENCRYPT )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
/* update */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( NULL, input_len,
|
||||
input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( &ctx, input_len,
|
||||
NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( &ctx, input_len,
|
||||
input, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_update_aad( NULL, aad, aad_len )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, NULL, aad_len )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_update( NULL, input_len, input, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, NULL, output )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_chachapoly_finish( NULL, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_chachapoly_finish( &ctx, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
/* finish */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_finish( NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_finish( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
mbedtls_chachapoly_free( &ctx );
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
|
||||
@ -22,72 +22,464 @@ void mbedtls_cipher_list( )
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void cipher_null_args( )
|
||||
void cipher_invalid_param_unconditional( )
|
||||
{
|
||||
mbedtls_cipher_context_t ctx;
|
||||
const mbedtls_cipher_info_t *info = mbedtls_cipher_info_from_type( *( mbedtls_cipher_list() ) );
|
||||
unsigned char buf[1] = { 0 };
|
||||
size_t olen;
|
||||
mbedtls_cipher_context_t valid_ctx;
|
||||
mbedtls_cipher_context_t invalid_ctx;
|
||||
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
|
||||
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
int valid_size = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_size * 8;
|
||||
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
|
||||
*( mbedtls_cipher_list() ) );
|
||||
size_t size_t_var;
|
||||
|
||||
mbedtls_cipher_init( &ctx );
|
||||
(void)valid_mode; /* In some configurations this is unused */
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_get_block_size( NULL ) == 0 );
|
||||
TEST_ASSERT( mbedtls_cipher_get_block_size( &ctx ) == 0 );
|
||||
mbedtls_cipher_init( &valid_ctx );
|
||||
mbedtls_cipher_setup( &valid_ctx, valid_info );
|
||||
mbedtls_cipher_init( &invalid_ctx );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_get_cipher_mode( NULL ) == MBEDTLS_MODE_NONE );
|
||||
TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &ctx ) == MBEDTLS_MODE_NONE );
|
||||
/* mbedtls_cipher_setup() */
|
||||
TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_get_iv_size( NULL ) == 0 );
|
||||
TEST_ASSERT( mbedtls_cipher_get_iv_size( &ctx ) == 0 );
|
||||
/* mbedtls_cipher_get_block_size() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_info_from_string( NULL ) == NULL );
|
||||
/* mbedtls_cipher_get_cipher_mode() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
|
||||
MBEDTLS_MODE_NONE );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_setup( &ctx, NULL )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_setup( NULL, info )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_get_iv_size() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_setkey( NULL, buf, 0, MBEDTLS_ENCRYPT )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_setkey( &ctx, buf, 0, MBEDTLS_ENCRYPT )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_get_type() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_get_type( &invalid_ctx ) ==
|
||||
MBEDTLS_CIPHER_NONE);
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_set_iv( NULL, buf, 0 )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, buf, 0 )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_get_name() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_reset( NULL ) == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_reset( &ctx ) == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_get_key_bitlen() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
|
||||
MBEDTLS_KEY_LENGTH_NONE );
|
||||
|
||||
/* mbedtls_cipher_get_operation() */
|
||||
TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
|
||||
MBEDTLS_OPERATION_NONE );
|
||||
|
||||
/* mbedtls_cipher_setkey() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_setkey( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_bitlen,
|
||||
valid_operation ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
/* mbedtls_cipher_set_iv() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_set_iv( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_size ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
/* mbedtls_cipher_reset() */
|
||||
TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
TEST_ASSERT( mbedtls_cipher_update_ad( NULL, buf, 0 )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_update_ad( &ctx, buf, 0 )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_update_ad() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_update_ad( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_size ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
||||
/* mbedtls_cipher_set_padding_mode() */
|
||||
TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
#endif
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_update( NULL, buf, 0, buf, &olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_update( &ctx, buf, 0, buf, &olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_update() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_update( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_size,
|
||||
valid_buffer,
|
||||
&size_t_var ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_finish( NULL, buf, &olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_finish( &ctx, buf, &olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_finish() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_finish( &invalid_ctx,
|
||||
valid_buffer,
|
||||
&size_t_var ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
TEST_ASSERT( mbedtls_cipher_write_tag( NULL, buf, olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_write_tag( &ctx, buf, olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_write_tag() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_write_tag( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_size ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_cipher_check_tag( NULL, buf, olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_cipher_check_tag( &ctx, buf, olen )
|
||||
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
/* mbedtls_cipher_check_tag() */
|
||||
TEST_ASSERT(
|
||||
mbedtls_cipher_check_tag( &invalid_ctx,
|
||||
valid_buffer,
|
||||
valid_size ) ==
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
exit:
|
||||
mbedtls_cipher_free( &invalid_ctx );
|
||||
mbedtls_cipher_free( &valid_ctx );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void cipher_invalid_param_conditional( )
|
||||
{
|
||||
mbedtls_cipher_context_t valid_ctx;
|
||||
|
||||
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
|
||||
mbedtls_operation_t invalid_operation = 100;
|
||||
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
int valid_size = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_size * 8;
|
||||
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
|
||||
*( mbedtls_cipher_list() ) );
|
||||
|
||||
size_t size_t_var;
|
||||
|
||||
(void)valid_mode; /* In some configurations this is unused */
|
||||
|
||||
/* mbedtls_cipher_init() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_setup() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setup( NULL, valid_info ) );
|
||||
|
||||
/* mbedtls_cipher_get_block_size() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_cipher_mode() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_MODE_NONE,
|
||||
mbedtls_cipher_get_cipher_mode( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_iv_size() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_type() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_CIPHER_NONE,
|
||||
mbedtls_cipher_get_type( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_name() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_key_bitlen() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_KEY_LENGTH_NONE,
|
||||
mbedtls_cipher_get_key_bitlen( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_operation() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_OPERATION_NONE,
|
||||
mbedtls_cipher_get_operation( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_setkey() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( NULL,
|
||||
valid_buffer,
|
||||
valid_bitlen,
|
||||
valid_operation ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( &valid_ctx,
|
||||
NULL,
|
||||
valid_bitlen,
|
||||
valid_operation ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( &valid_ctx,
|
||||
valid_buffer,
|
||||
valid_bitlen,
|
||||
invalid_operation ) );
|
||||
|
||||
/* mbedtls_cipher_set_iv() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_iv( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_iv( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_reset() */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_reset( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
/* mbedtls_cipher_update_ad() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update_ad( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update_ad( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
||||
/* mbedtls_cipher_set_padding_mode() */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
|
||||
#endif
|
||||
|
||||
/* mbedtls_cipher_update() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( NULL,
|
||||
valid_buffer,
|
||||
valid_size,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer,
|
||||
NULL ) );
|
||||
|
||||
/* mbedtls_cipher_finish() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( NULL,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( &valid_ctx,
|
||||
NULL,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( &valid_ctx,
|
||||
valid_buffer,
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
/* mbedtls_cipher_write_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_write_tag( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_write_tag( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_check_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_check_tag( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_check_tag( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
/* mbedtls_cipher_crypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_AEAD)
|
||||
/* mbedtls_cipher_auth_encrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
NULL, valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, &size_t_var,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var,
|
||||
NULL, valid_size ) );
|
||||
#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
|
||||
|
||||
/* mbedtls_cipher_free() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
|
||||
exit:
|
||||
TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
@ -570,6 +962,8 @@ void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
|
||||
#else
|
||||
if( use_psa == 1 )
|
||||
{
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
|
||||
/* PSA requires that the tag immediately follows the ciphertext. */
|
||||
tmp_cipher = mbedtls_calloc( 1, cipher->len + tag->len );
|
||||
TEST_ASSERT( tmp_cipher != NULL );
|
||||
@ -712,6 +1106,7 @@ void test_vec_crypt( int cipher_id, int operation, char *hex_key,
|
||||
#else
|
||||
if( use_psa == 1 )
|
||||
{
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( &ctx,
|
||||
mbedtls_cipher_info_from_type( cipher_id ), 0 ) );
|
||||
}
|
||||
|
||||
5
tests/suites/test_suite_cipher.misc.data
Normal file
5
tests/suites/test_suite_cipher.misc.data
Normal file
@ -0,0 +1,5 @@
|
||||
CIPHER - Conditional invalid parameter checks
|
||||
cipher_invalid_param_conditional:
|
||||
|
||||
CIPHER - Unconditional invalid parameter checks
|
||||
cipher_invalid_param_unconditional:
|
||||
@ -1,9 +1,6 @@
|
||||
Cipher list
|
||||
mbedtls_cipher_list:
|
||||
|
||||
Cipher null/uninitialised arguments
|
||||
cipher_null_args:
|
||||
|
||||
Set padding with AES-CBC
|
||||
depends_on:MBEDTLS_AES_C:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_CIPHER_PADDING_PKCS7
|
||||
set_padding:MBEDTLS_CIPHER_AES_128_CBC:MBEDTLS_PADDING_PKCS7:0
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
Diffie-Hellman parameter validation
|
||||
dhm_invalid_params:
|
||||
|
||||
Diffie-Hellman full exchange #1
|
||||
dhm_do_dhm:10:"23":10:"5":0
|
||||
|
||||
|
||||
@ -7,6 +7,113 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void dhm_invalid_params( )
|
||||
{
|
||||
mbedtls_dhm_context ctx;
|
||||
unsigned char buf[42] = { 0 };
|
||||
unsigned char *buf_null = NULL;
|
||||
mbedtls_mpi X;
|
||||
size_t const buflen = sizeof( buf );
|
||||
size_t len;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_dhm_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_dhm_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( NULL,
|
||||
(unsigned char**) &buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx, &buf_null, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx,
|
||||
(unsigned char**) &buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( NULL, buflen,
|
||||
buf, &len,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
NULL, &len,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
buf, NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
buf, &len,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( &ctx, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( &ctx, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_public( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_public( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( NULL, buflen,
|
||||
buf, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( &ctx, buflen,
|
||||
NULL, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( &ctx, buflen,
|
||||
buf, buflen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( NULL, buf, buflen,
|
||||
&len, rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( &ctx, NULL, buflen,
|
||||
&len, rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( &ctx, buf, buflen,
|
||||
NULL, rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ASN1_PARSE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhm( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhm( &ctx, NULL, buflen ) );
|
||||
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhmfile( NULL, "" ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhmfile( &ctx, NULL ) );
|
||||
#endif /* MBEDTLS_FS_IO */
|
||||
#endif /* MBEDTLS_ASN1_PARSE_C */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void dhm_do_dhm( int radix_P, char *input_P,
|
||||
int radix_G, char *input_G, int result )
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
ECDH - Valid parameters
|
||||
ecdh_valid_param:
|
||||
|
||||
ECDH - Invalid parameters
|
||||
ecdh_invalid_param:
|
||||
|
||||
ECDH primitive random #1
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecdh_primitive_random:MBEDTLS_ECP_DP_SECP192R1
|
||||
|
||||
@ -7,6 +7,148 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecdh_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_ecdh_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecdh_invalid_param( )
|
||||
{
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecdh_context ctx;
|
||||
mbedtls_mpi m;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_ecp_keypair kp;
|
||||
size_t olen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
const unsigned char *buf_null = NULL;
|
||||
size_t const buflen = sizeof( buf );
|
||||
int invalid_side = 42;
|
||||
mbedtls_ecp_group_id valid_grp = MBEDTLS_ECP_DP_SECP192R1;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecdh_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecdh_enable_restart( NULL ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( NULL, &m, &P,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, NULL, &P,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, &m, NULL,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, &m, &P,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( NULL, &m, &P, &m,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, NULL, &P, &m,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, &m, NULL, &m,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, &m, &P, NULL,
|
||||
rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_setup( NULL, valid_grp ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( NULL, &olen,
|
||||
buf, buflen,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, NULL,
|
||||
buf, buflen,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, &olen,
|
||||
NULL, buflen,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, &olen,
|
||||
buf, buflen,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( NULL,
|
||||
(const unsigned char**) &buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx, &buf_null,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx,
|
||||
(const unsigned char**) &buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( NULL, &kp,
|
||||
MBEDTLS_ECDH_OURS ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( &ctx, NULL,
|
||||
MBEDTLS_ECDH_OURS ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( &ctx, &kp,
|
||||
invalid_side ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( NULL, &olen,
|
||||
buf, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, NULL,
|
||||
buf, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, &olen,
|
||||
NULL, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, &olen,
|
||||
buf, buflen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_public( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_public( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( NULL, &olen, buf, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( &ctx, NULL, buf, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( &ctx, &olen, NULL, buflen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecdh_primitive_random( int id )
|
||||
{
|
||||
@ -209,7 +351,7 @@ void ecdh_restart( int id, char *dA_str, char *dB_str, char *z_str,
|
||||
mbedtls_ecdh_enable_restart( &cli );
|
||||
}
|
||||
|
||||
/* server writes its paramaters */
|
||||
/* server writes its parameters */
|
||||
memset( buf, 0x00, sizeof( buf ) );
|
||||
len = 0;
|
||||
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
ECDSA Parameter validation
|
||||
ecdsa_invalid_param:
|
||||
|
||||
ECDSA primitive random #1
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecdsa_prim_random:MBEDTLS_ECP_DP_SECP192R1
|
||||
|
||||
@ -7,6 +7,201 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecdsa_invalid_param( )
|
||||
{
|
||||
mbedtls_ecdsa_context ctx;
|
||||
mbedtls_ecp_keypair key;
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP192R1;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
mbedtls_mpi m;
|
||||
size_t slen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecdsa_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecdsa_free( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecdsa_restart_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecdsa_restart_free( NULL ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( NULL, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, NULL, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, NULL, &m,
|
||||
buf, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, NULL,
|
||||
buf, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, &m,
|
||||
NULL, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det( NULL, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det( &grp, NULL, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det( &grp, &m, NULL, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det( &grp, &m, &m, NULL,
|
||||
buf, sizeof( buf ),
|
||||
valid_md ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det( &grp, &m, &m, &m,
|
||||
NULL, sizeof( buf ),
|
||||
valid_md ) );
|
||||
#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( NULL,
|
||||
buf, sizeof( buf ),
|
||||
&P, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
NULL, sizeof( buf ),
|
||||
&P, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
&P, NULL, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
&P, &m, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( NULL,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
buf, &slen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx,
|
||||
valid_md,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &slen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &slen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
buf, NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( NULL,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
buf, &slen,
|
||||
rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx,
|
||||
valid_md,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &slen,
|
||||
rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &slen,
|
||||
rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx,
|
||||
valid_md,
|
||||
buf, sizeof( buf ),
|
||||
buf, NULL,
|
||||
rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( &ctx,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( &ctx,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( &ctx,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( &ctx,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ),
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_genkey( NULL, valid_group,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_genkey( &ctx, valid_group,
|
||||
NULL, NULL ) );
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_from_keypair( NULL, &key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_from_keypair( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecdsa_prim_random( int id )
|
||||
{
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
ECJPAKE parameter validation
|
||||
ecjpake_invalid_param:
|
||||
|
||||
ECJPAKE selftest
|
||||
ecjpake_selftest:
|
||||
|
||||
|
||||
@ -98,6 +98,137 @@ cleanup:
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecjpake_invalid_param( )
|
||||
{
|
||||
mbedtls_ecjpake_context ctx;
|
||||
unsigned char buf[42] = { 0 };
|
||||
size_t olen;
|
||||
size_t const len = sizeof( buf );
|
||||
mbedtls_ecjpake_role valid_role = MBEDTLS_ECJPAKE_SERVER;
|
||||
mbedtls_ecjpake_role invalid_role = (mbedtls_ecjpake_role) 42;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP256R1;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecjpake_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecjpake_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( NULL,
|
||||
valid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( &ctx,
|
||||
invalid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( &ctx,
|
||||
valid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_check( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( NULL,
|
||||
buf, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx,
|
||||
NULL, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx,
|
||||
buf, len,
|
||||
NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx,
|
||||
buf, len,
|
||||
&olen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( NULL,
|
||||
buf, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx,
|
||||
NULL, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx,
|
||||
buf, len,
|
||||
NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx,
|
||||
buf, len,
|
||||
&olen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_one( NULL,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_one( &ctx,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_two( NULL,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_two( &ctx,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( NULL,
|
||||
buf, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx,
|
||||
NULL, len,
|
||||
&olen,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx,
|
||||
buf, len,
|
||||
NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx,
|
||||
buf, len,
|
||||
&olen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void ecjpake_selftest( )
|
||||
{
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
ECP valid params
|
||||
ecp_valid_param:
|
||||
|
||||
ECP invalid params
|
||||
ecp_invalid_param:
|
||||
|
||||
ECP curve info #1
|
||||
depends_on:MBEDTLS_ECP_DP_BP512R1_ENABLED
|
||||
mbedtls_ecp_curve_info:MBEDTLS_ECP_DP_BP512R1:28:512:"brainpoolP512r1"
|
||||
@ -46,10 +52,6 @@ ECP check pubkey Koblitz #2 (coordinate not affine)
|
||||
depends_on:MBEDTLS_ECP_DP_SECP224K1_ENABLED
|
||||
ecp_check_pub:MBEDTLS_ECP_DP_SECP224K1:"E2000000000000BB3A13D43B323337383935321F0603551D":"100101FF040830060101FF02010A30220603551D0E041B04636FC0C0":"101":MBEDTLS_ERR_ECP_INVALID_KEY
|
||||
|
||||
ECP write binary #0 (zero, bad format)
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecp_write_binary:MBEDTLS_ECP_DP_SECP192R1:"01":"01":"00":ECP_PF_UNKNOWN:"00":1:MBEDTLS_ERR_ECP_BAD_INPUT_DATA
|
||||
|
||||
ECP write binary #1 (zero, uncompressed, buffer just fits)
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecp_write_binary:MBEDTLS_ECP_DP_SECP192R1:"01":"01":"00":MBEDTLS_ECP_PF_UNCOMPRESSED:"00":1:0
|
||||
|
||||
@ -13,6 +13,349 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecp_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_ecp_group_free( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecp_keypair_free( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecp_point_free( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_VALID_PARAM( mbedtls_ecp_restart_free( NULL ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecp_invalid_param( )
|
||||
{
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecp_keypair kp;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_mpi m;
|
||||
const char *x = "deadbeef";
|
||||
int valid_fmt = MBEDTLS_ECP_PF_UNCOMPRESSED;
|
||||
int invalid_fmt = 42;
|
||||
size_t olen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
const unsigned char *null_buf = NULL;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP192R1;
|
||||
mbedtls_ecp_restart_ctx restart_ctx;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_point_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_keypair_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_group_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_restart_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_check_budget( NULL, &restart_ctx, 42 ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_copy( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_copy( &P, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_copy( NULL, &grp ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_copy( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( NULL,
|
||||
&m,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( &grp,
|
||||
NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( &grp,
|
||||
&m,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_set_zero( NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_is_zero( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_cmp( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_cmp( &P, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( NULL, 2,
|
||||
x, x ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( &P, 2,
|
||||
NULL, x ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( &P, 2,
|
||||
x, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( NULL, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, NULL,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
invalid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
valid_fmt,
|
||||
NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( NULL, &P, buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( &grp, NULL, buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( &grp, &P, NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( NULL, &P,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, &P, &null_buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, &P, NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( NULL, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, NULL,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
invalid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
valid_fmt,
|
||||
NULL,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_load( NULL, valid_group ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( &grp, NULL,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( &grp, &null_buf,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( &valid_group, NULL,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( &valid_group,
|
||||
&null_buf,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( NULL, &olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( &grp, NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( &grp, &olen,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( NULL, &P, &m, &P,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, NULL, &m, &P,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, &P, NULL, &P,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, &P, &m, NULL,
|
||||
rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( NULL, &P, &m, &P,
|
||||
rnd_std_rand, NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, NULL, &m, &P,
|
||||
rnd_std_rand, NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, &P, NULL, &P,
|
||||
rnd_std_rand, NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, &P, &m, NULL,
|
||||
rnd_std_rand, NULL , NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( NULL, &P, &m, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, NULL, &m, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, NULL, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, NULL,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, &P,
|
||||
NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, &P,
|
||||
&m, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( NULL, &P, &m, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, NULL, &m, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, NULL, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, NULL,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
|
||||
NULL, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
|
||||
&m, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pubkey( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pubkey( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pub_priv( NULL, &kp ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pub_priv( &kp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_privkey( NULL, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_privkey( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( NULL, &P,
|
||||
&m, &P,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, NULL,
|
||||
&m, &P,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P,
|
||||
NULL, &P,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P,
|
||||
&m, NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P,
|
||||
&m, &P,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( NULL,
|
||||
&m, &P,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
NULL, &P,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
&m, NULL,
|
||||
rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
&m, &P,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_key( valid_group, NULL,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_key( valid_group, &kp,
|
||||
NULL, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mbedtls_ecp_curve_info( int id, int tls_id, int size, char * name )
|
||||
{
|
||||
|
||||
@ -103,6 +103,175 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void gcm_invalid_param( )
|
||||
{
|
||||
mbedtls_gcm_context ctx;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
|
||||
int valid_mode = MBEDTLS_GCM_ENCRYPT;
|
||||
int valid_len = sizeof(valid_buffer);
|
||||
int valid_bitlen = 128, invalid_bitlen = 1;
|
||||
|
||||
mbedtls_gcm_init( &ctx );
|
||||
|
||||
/* mbedtls_gcm_init() */
|
||||
TEST_INVALID_PARAM( mbedtls_gcm_init( NULL ) );
|
||||
|
||||
/* mbedtls_gcm_setkey */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( &ctx, valid_cipher, valid_buffer, invalid_bitlen ) );
|
||||
|
||||
/* mbedtls_gcm_crypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( NULL, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, NULL ) );
|
||||
|
||||
/* mbedtls_gcm_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL) );
|
||||
|
||||
/* mbedtls_gcm_starts() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( NULL, valid_mode,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( &ctx, valid_mode,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( &ctx, valid_mode,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_gcm_update() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( NULL, valid_len,
|
||||
valid_buffer, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( &ctx, valid_len,
|
||||
NULL, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( &ctx, valid_len,
|
||||
valid_buffer, NULL ) );
|
||||
|
||||
/* mbedtls_gcm_finish() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_finish( NULL, valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_finish( &ctx, NULL, valid_len ) );
|
||||
|
||||
exit:
|
||||
mbedtls_gcm_free( &ctx );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void gcm_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_gcm_free( NULL ) );
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void gcm_selftest( )
|
||||
{
|
||||
|
||||
5
tests/suites/test_suite_gcm.misc.data
Normal file
5
tests/suites/test_suite_gcm.misc.data
Normal file
@ -0,0 +1,5 @@
|
||||
GCM - Invalid parameters
|
||||
gcm_invalid_param:
|
||||
|
||||
GCM - Valid parameters
|
||||
gcm_valid_param:
|
||||
@ -1,3 +1,9 @@
|
||||
MPI - Valid parameters
|
||||
mpi_valid_param:
|
||||
|
||||
MPI - Invalid parameters
|
||||
mpi_invalid_param:
|
||||
|
||||
Arguments with no value
|
||||
mpi_null:
|
||||
|
||||
|
||||
@ -50,6 +50,220 @@ int mbedtls_test_mpi_miller_rabin_determinizer( void* state,
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mpi_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_mpi_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void mpi_invalid_param( )
|
||||
{
|
||||
mbedtls_mpi X;
|
||||
const char *s_in = "00101000101010";
|
||||
char s_out[16] = { 0 };
|
||||
unsigned char u_out[16] = { 0 };
|
||||
unsigned char u_in[16] = { 0 };
|
||||
size_t olen;
|
||||
mbedtls_mpi_uint mpi_uint;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_grow( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_copy( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_copy( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_swap( NULL, &X ) );
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_swap( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_assign( NULL, &X, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_assign( &X, NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_swap( NULL, &X, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_swap( &X, NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_lset( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_get_bit( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_set_bit( NULL, 42, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_string( NULL, 2, s_in ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_string( &X, 2, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( NULL, 2,
|
||||
s_out, sizeof( s_out ),
|
||||
&olen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( &X, 2,
|
||||
NULL, sizeof( s_out ),
|
||||
&olen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( &X, 2,
|
||||
s_out, sizeof( s_out ),
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_file( NULL, 2, stdin ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_file( &X, 2, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_file( "", NULL, 2, NULL ) );
|
||||
#endif /* MBEDTLS_FS_IO */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_binary( NULL, u_in,
|
||||
sizeof( u_in ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_binary( &X, NULL,
|
||||
sizeof( u_in ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_binary( NULL, u_out,
|
||||
sizeof( u_out ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_binary( &X, NULL,
|
||||
sizeof( u_out ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_shift_l( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_shift_r( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_abs( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_abs( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_mpi( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_mpi( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_int( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_mpi( &X, &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_mpi( &X, &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_int( &X, &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_mpi_lsb( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_int( &mpi_uint, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( NULL, &X, &X, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, NULL, &X, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, &X, NULL, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, &X, &X, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_fill_random( NULL, 42, rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_fill_random( &X, 42, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( &X, &X, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mpi_null( )
|
||||
{
|
||||
|
||||
@ -30,7 +30,7 @@ void mbedtls_nist_kw_mix_contexts( )
|
||||
memset( key, 0, sizeof( key ) );
|
||||
|
||||
/*
|
||||
* 1. Check wrap and unwrap with two seperate contexts
|
||||
* 1. Check wrap and unwrap with two separate contexts
|
||||
*/
|
||||
mbedtls_nist_kw_init( &ctx1 );
|
||||
mbedtls_nist_kw_init( &ctx2 );
|
||||
|
||||
@ -1,3 +1,13 @@
|
||||
PK invalid parameters
|
||||
invalid_parameters:
|
||||
|
||||
PK valid parameters
|
||||
valid_parameters:
|
||||
|
||||
PK write valid parameters
|
||||
depends_on:MBEDTLS_RSA_C
|
||||
valid_parameters_pkwrite:"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"
|
||||
|
||||
PK utils: RSA
|
||||
depends_on:MBEDTLS_RSA_C:MBEDTLS_GENPRIME
|
||||
pk_utils:MBEDTLS_PK_RSA:512:64:"RSA"
|
||||
|
||||
@ -2,6 +2,8 @@
|
||||
#include "mbedtls/pk.h"
|
||||
|
||||
/* For error codes */
|
||||
#include "mbedtls/asn1.h"
|
||||
#include "mbedtls/base64.h"
|
||||
#include "mbedtls/ecp.h"
|
||||
#include "mbedtls/rsa.h"
|
||||
|
||||
@ -122,6 +124,8 @@ void pk_psa_utils( )
|
||||
size_t len;
|
||||
mbedtls_pk_debug_item dbg;
|
||||
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
|
||||
mbedtls_pk_init( &pk );
|
||||
mbedtls_pk_init( &pk2 );
|
||||
|
||||
@ -179,6 +183,426 @@ exit:
|
||||
/* END_CASE */
|
||||
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void valid_parameters( )
|
||||
{
|
||||
mbedtls_pk_context pk;
|
||||
unsigned char buf[1];
|
||||
size_t len;
|
||||
void *options = NULL;
|
||||
|
||||
mbedtls_pk_init( &pk );
|
||||
|
||||
TEST_VALID_PARAM( mbedtls_pk_free( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_VALID_PARAM( mbedtls_pk_restart_free( NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
/* In informational functions, we accept NULL where a context pointer
|
||||
* is expected because that's what the library has done forever.
|
||||
* We do not document that NULL is accepted, so we may wish to change
|
||||
* the behavior in a future version. */
|
||||
TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
|
||||
TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
|
||||
TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_sign( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ),
|
||||
NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_verify( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_encrypt( &pk,
|
||||
NULL, 0,
|
||||
NULL, &len, 0,
|
||||
rnd_std_rand, NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_decrypt( &pk,
|
||||
NULL, 0,
|
||||
NULL, &len, 0,
|
||||
rnd_std_rand, NULL ) ==
|
||||
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
|
||||
|
||||
#if defined(MBEDTLS_PK_PARSE_C)
|
||||
TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
|
||||
MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
|
||||
MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
|
||||
#endif /* MBEDTLS_PK_PARSE_C */
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
|
||||
void valid_parameters_pkwrite( data_t *key_data )
|
||||
{
|
||||
mbedtls_pk_context pk;
|
||||
|
||||
/* For the write tests to be effective, we need a valid key pair. */
|
||||
mbedtls_pk_init( &pk );
|
||||
TEST_ASSERT( mbedtls_pk_parse_key( &pk,
|
||||
key_data->x, key_data->len,
|
||||
NULL, 0 ) == 0 );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
|
||||
MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
|
||||
MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
|
||||
|
||||
#if defined(MBEDTLS_PEM_WRITE_C)
|
||||
TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
|
||||
MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
|
||||
|
||||
TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
|
||||
MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
|
||||
#endif /* MBEDTLS_PEM_WRITE_C */
|
||||
|
||||
exit:
|
||||
mbedtls_pk_free( &pk );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void invalid_parameters( )
|
||||
{
|
||||
size_t len;
|
||||
unsigned char *null_buf = NULL;
|
||||
unsigned char buf[1];
|
||||
unsigned char *p = buf;
|
||||
char str[1] = {0};
|
||||
mbedtls_pk_context pk;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
void *options = buf;
|
||||
|
||||
(void) null_buf;
|
||||
(void) p;
|
||||
(void) str;
|
||||
|
||||
mbedtls_pk_init( &pk );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_setup( NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_setup_rsa_alt( NULL, buf,
|
||||
NULL, NULL, NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ),
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &len,
|
||||
rnd_std_rand, NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, &len,
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &len,
|
||||
rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk,
|
||||
buf, sizeof( buf ),
|
||||
buf, NULL, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk,
|
||||
NULL, sizeof( buf ),
|
||||
buf, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &len, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk,
|
||||
buf, sizeof( buf ),
|
||||
buf, NULL, sizeof( buf ),
|
||||
rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_check_pair( NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_check_pair( &pk, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_debug( NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_PK_PARSE_C)
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( NULL, &p, &len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( str, NULL, &len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( str, &p, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_keyfile( NULL, str ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_key( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_key( &pk,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_key( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_key( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
#endif /* MBEDTLS_PK_PARSE_C */
|
||||
|
||||
#if defined(MBEDTLS_PK_WRITE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( NULL, p, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &p, p, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_der( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_der( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_der( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_der( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
#if defined(MBEDTLS_PEM_WRITE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_pem( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_pem( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_pem( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_pem( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
#endif /* MBEDTLS_PEM_WRITE_C */
|
||||
|
||||
#endif /* MBEDTLS_PK_WRITE_C */
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void pk_utils( int type, int size, int len, char * name )
|
||||
{
|
||||
|
||||
@ -88,7 +88,7 @@ void mbedtls_poly1305( char *hex_key_string, char *hex_mac_string, char *hex_src
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void poly1305_bad_params()
|
||||
{
|
||||
unsigned char src[1];
|
||||
@ -97,38 +97,33 @@ void poly1305_bad_params()
|
||||
size_t src_len = sizeof( src );
|
||||
mbedtls_poly1305_context ctx;
|
||||
|
||||
mbedtls_poly1305_init( NULL );
|
||||
mbedtls_poly1305_free( NULL );
|
||||
TEST_INVALID_PARAM( mbedtls_poly1305_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_poly1305_free( NULL ) );
|
||||
|
||||
mbedtls_poly1305_init( &ctx );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_starts( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_starts( &ctx, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_poly1305_starts( NULL, key )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_starts( &ctx, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_update( NULL, src, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_update( &ctx, NULL, src_len ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_poly1305_update( NULL, src, 0 )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_update( &ctx, NULL, src_len )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_update( &ctx, NULL, 0 )
|
||||
== 0 );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_finish( NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_finish( &ctx, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_poly1305_finish( NULL, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_finish( &ctx, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( NULL, src, 0, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( key, NULL, src_len, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( key, src, 0, NULL ) );
|
||||
|
||||
TEST_ASSERT( mbedtls_poly1305_mac( NULL, src, 0, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_mac( key, NULL, src_len, mac )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_mac( key, src, 0, NULL )
|
||||
== MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
|
||||
TEST_ASSERT( mbedtls_poly1305_mac( key, NULL, 0, mac )
|
||||
== 0 );
|
||||
|
||||
mbedtls_poly1305_free( &ctx );
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
RSA parameter validation
|
||||
rsa_invalid_param:
|
||||
|
||||
RSA PKCS1 Verify v1.5 CAVS #1
|
||||
depends_on:MBEDTLS_SHA1_C:MBEDTLS_PKCS1_V15
|
||||
# Good padding but wrong hash
|
||||
@ -255,12 +258,6 @@ RSA PKCS1 Sign #9 Verify (Invalid Digest type)
|
||||
depends_on:MBEDTLS_PKCS1_V15
|
||||
mbedtls_rsa_pkcs1_verify:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":MBEDTLS_RSA_PKCS_V15:255:2048:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":MBEDTLS_ERR_RSA_BAD_INPUT_DATA
|
||||
|
||||
RSA PKCS1 Sign #8 (Invalid padding type)
|
||||
mbedtls_rsa_pkcs1_sign:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":2:MBEDTLS_MD_MD5:2048:16:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":16:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":MBEDTLS_ERR_RSA_INVALID_PADDING
|
||||
|
||||
RSA PKCS1 Sign #8 Verify (Invalid padding type)
|
||||
mbedtls_rsa_pkcs1_verify:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":1:MBEDTLS_MD_MD5:2048:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":MBEDTLS_ERR_RSA_INVALID_PADDING
|
||||
|
||||
RSA PKCS1 Encrypt #1
|
||||
depends_on:MBEDTLS_PKCS1_V15
|
||||
mbedtls_rsa_pkcs1_encrypt:"4E636AF98E40F3ADCFCCB698F4E80B9F":MBEDTLS_RSA_PKCS_V15:2048:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":"b0c0b193ba4a5b4502bfacd1a9c2697da5510f3e3ab7274cf404418afd2c62c89b98d83bbc21c8c1bf1afe6d8bf40425e053e9c03e03a3be0edbe1eda073fade1cc286cc0305a493d98fe795634c3cad7feb513edb742d66d910c87d07f6b0055c3488bb262b5fd1ce8747af64801fb39d2d3a3e57086ffe55ab8d0a2ca86975629a0f85767a4990c532a7c2dab1647997ebb234d0b28a0008bfebfc905e7ba5b30b60566a5e0190417465efdbf549934b8f0c5c9f36b7c5b6373a47ae553ced0608a161b1b70dfa509375cf7a3598223a6d7b7a1d1a06ac74d345a9bb7c0e44c8388858a4f1d8115f2bd769ffa69020385fa286302c80e950f9e2751308666c":0
|
||||
@ -277,12 +274,6 @@ RSA PKCS1 Decrypt #2 (Data too small)
|
||||
depends_on:MBEDTLS_PKCS1_V15
|
||||
mbedtls_rsa_pkcs1_decrypt:"deadbeafcafedeadbeeffedcba9876":MBEDTLS_RSA_PKCS_V15:2048:16:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":16:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":1000:"4E636AF98E40F3ADCFCCB698F4E80B9F":MBEDTLS_ERR_RSA_PRIVATE_FAILED + MBEDTLS_ERR_MPI_BAD_INPUT_DATA
|
||||
|
||||
RSA PKCS1 Encrypt #3 (Invalid padding mode)
|
||||
mbedtls_rsa_pkcs1_encrypt:"4E636AF98E40F3ADCFCCB698F4E80B9F":2:2048:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":MBEDTLS_ERR_RSA_INVALID_PADDING
|
||||
|
||||
RSA PKCS1 Decrypt #3 (Invalid padding mode)
|
||||
mbedtls_rsa_pkcs1_decrypt:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":2:2048:16:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":16:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":1000:"4E636AF98E40F3ADCFCCB698F4E80B9F":MBEDTLS_ERR_RSA_INVALID_PADDING
|
||||
|
||||
RSA PKCS1 Decrypt #4 (Output buffer too small)
|
||||
depends_on:MBEDTLS_PKCS1_V15
|
||||
mbedtls_rsa_pkcs1_decrypt:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":MBEDTLS_RSA_PKCS_V15:2048:16:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":16:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"3":15:"4E636AF98E40F3ADCFCCB698F4E80B9F":MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE
|
||||
@ -339,6 +330,7 @@ RSA Check Public key #5 (N smaller than 128 bits)
|
||||
mbedtls_rsa_check_pubkey:16:"7edcba9876543210deadbeefcafe4321":16:"3":MBEDTLS_ERR_RSA_KEY_CHECK_FAILED
|
||||
|
||||
RSA Check Public key #6 (N exactly 8192 bits)
|
||||
depends_on:MBEDTLS_MPI_MAX_SIZE>=1024
|
||||
mbedtls_rsa_check_pubkey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
|
||||
|
||||
RSA Check Public key #7 (N larger than 8192 bits)
|
||||
@ -486,7 +478,7 @@ mbedtls_rsa_import:16:"":16:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bb
|
||||
RSA Import (N,-,-,D,E)
|
||||
mbedtls_rsa_import:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"":16:"":16:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":16:"3":0:1:0:0
|
||||
|
||||
RSA Import (N,-,-,D,E), succesive
|
||||
RSA Import (N,-,-,D,E), successive
|
||||
mbedtls_rsa_import:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"":16:"":16:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":16:"3":1:1:0:0
|
||||
|
||||
RSA Import (N,P,Q,-,E)
|
||||
@ -573,7 +565,7 @@ mbedtls_rsa_export:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7
|
||||
RSA Export (N,-,-,D,E)
|
||||
mbedtls_rsa_export:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"":16:"":16:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":16:"3":1:0
|
||||
|
||||
RSA Export (N,-,-,D,E), succesive
|
||||
RSA Export (N,-,-,D,E), successive
|
||||
mbedtls_rsa_export:16:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":16:"":16:"":16:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":16:"3":1:1
|
||||
|
||||
RSA Export (N,P,Q,-,E)
|
||||
@ -594,7 +586,7 @@ mbedtls_rsa_export_raw:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f
|
||||
RSA Export Raw (N,-,-,D,E)
|
||||
mbedtls_rsa_export_raw:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":"":"":"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":"03":1:0
|
||||
|
||||
RSA Export Raw (N,-,-,D,E), succesive
|
||||
RSA Export Raw (N,-,-,D,E), successive
|
||||
mbedtls_rsa_export_raw:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":"":"":"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":"03":1:1
|
||||
|
||||
RSA Export Raw (N,P,Q,-,E)
|
||||
|
||||
@ -17,6 +17,454 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void rsa_invalid_param( )
|
||||
{
|
||||
mbedtls_rsa_context ctx;
|
||||
const int valid_padding = MBEDTLS_RSA_PKCS_V21;
|
||||
const int invalid_padding = 42;
|
||||
const int valid_mode = MBEDTLS_RSA_PRIVATE;
|
||||
const int invalid_mode = 42;
|
||||
unsigned char buf[42] = { 0 };
|
||||
size_t olen;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_init( NULL, valid_padding, 0 ) );
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_init( &ctx, invalid_padding, 0 ) );
|
||||
TEST_VALID_PARAM( mbedtls_rsa_free( NULL ) );
|
||||
|
||||
/* No more variants because only the first argument must be non-NULL. */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_import( NULL, NULL, NULL,
|
||||
NULL, NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_import_raw( NULL,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_complete( NULL ) );
|
||||
|
||||
/* No more variants because only the first argument must be non-NULL. */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export( NULL, NULL, NULL,
|
||||
NULL, NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export_raw( NULL,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export_crt( NULL, NULL, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( NULL,
|
||||
valid_padding, 0 ) );
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( &ctx,
|
||||
invalid_padding, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_gen_key( NULL, rnd_std_rand,
|
||||
NULL, 0, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_gen_key( &ctx, NULL,
|
||||
NULL, 0, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pubkey( NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_privkey( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pub_priv( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pub_priv( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( &ctx, buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( NULL, NULL, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( &ctx, NULL, NULL,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( &ctx, NULL, NULL,
|
||||
buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
NULL, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( NULL, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
invalid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
NULL, sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1, 0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf,
|
||||
0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf,
|
||||
0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, 0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, 0, 0,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
0, 0,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_copy( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_copy( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mbedtls_rsa_pkcs1_sign( data_t * message_str, int padding_mode,
|
||||
int digest, int mod, int radix_P, char * input_P,
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
SHA-1 - Valid parameters
|
||||
sha1_valid_param:
|
||||
|
||||
SHA-1 - Invalid parameters
|
||||
sha1_invalid_param:
|
||||
|
||||
# Test the operation of SHA-1 and SHA-2
|
||||
SHA-1 Test Vector NIST CAVS #1
|
||||
depends_on:MBEDTLS_SHA1_C
|
||||
@ -39,6 +45,12 @@ SHA-1 Test Vector NIST CAVS #10
|
||||
depends_on:MBEDTLS_SHA1_C
|
||||
mbedtls_sha1:"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7acced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d204b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb099927c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd470552430d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca392899ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26ec0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a26bab26279f1bf6724ff":"11863b483809ef88413ca9b0084ac4a5390640af"
|
||||
|
||||
SHA-256 Valid parameters
|
||||
sha256_valid_param:
|
||||
|
||||
SHA-256 Invalid parameters
|
||||
sha256_invalid_param:
|
||||
|
||||
SHA-224 Test Vector NIST CAVS #1
|
||||
depends_on:MBEDTLS_SHA256_C
|
||||
sha224:"":"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"
|
||||
@ -95,6 +107,12 @@ SHA-256 Test Vector NIST CAVS #7
|
||||
depends_on:MBEDTLS_SHA256_C
|
||||
mbedtls_sha256:"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e":"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e"
|
||||
|
||||
SHA-512 Invalid parameters
|
||||
sha512_invalid_param:
|
||||
|
||||
SHA-512 Valid parameters
|
||||
sha512_valid_param:
|
||||
|
||||
SHA-384 Test Vector NIST CAVS #1
|
||||
depends_on:MBEDTLS_SHA512_C
|
||||
sha384:"":"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"
|
||||
|
||||
@ -4,6 +4,53 @@
|
||||
#include "mbedtls/sha512.h"
|
||||
/* END_HEADER */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
|
||||
void sha1_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_sha1_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha1_invalid_param( )
|
||||
{
|
||||
mbedtls_sha1_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_starts_ret( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha1_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha1_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_ret( NULL, buflen, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_ret( buf, buflen, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
|
||||
void mbedtls_sha1( data_t * src_str, data_t * hex_hash_string )
|
||||
{
|
||||
@ -18,6 +65,62 @@ void mbedtls_sha1( data_t * src_str, data_t * hex_hash_string )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
|
||||
void sha256_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_sha256_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha256_invalid_param( )
|
||||
{
|
||||
mbedtls_sha256_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
int valid_type = 0;
|
||||
int invalid_type = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_starts_ret( NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_starts_ret( &ctx, invalid_type ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha256_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha256_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( NULL, buflen,
|
||||
buf, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( buf, buflen,
|
||||
NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( buf, buflen,
|
||||
buf, invalid_type ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
|
||||
void sha224( data_t * src_str, data_t * hex_hash_string )
|
||||
{
|
||||
@ -46,6 +149,62 @@ void mbedtls_sha256( data_t * src_str, data_t * hex_hash_string )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
|
||||
void sha512_valid_param( )
|
||||
{
|
||||
TEST_VALID_PARAM( mbedtls_sha512_free( NULL ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha512_invalid_param( )
|
||||
{
|
||||
mbedtls_sha512_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
int valid_type = 0;
|
||||
int invalid_type = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_starts_ret( NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_starts_ret( &ctx, invalid_type ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha512_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha512_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( NULL, buflen,
|
||||
buf, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( buf, buflen,
|
||||
NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( buf, buflen,
|
||||
buf, invalid_type ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
|
||||
void sha384( data_t * src_str, data_t * hex_hash_string )
|
||||
{
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
Check compiletime library version
|
||||
check_compiletime_version:"2.14.0"
|
||||
check_compiletime_version:"2.16.0"
|
||||
|
||||
Check runtime library version
|
||||
check_runtime_version:"2.14.0"
|
||||
check_runtime_version:"2.16.0"
|
||||
|
||||
Check for MBEDTLS_VERSION_C
|
||||
check_feature:"MBEDTLS_VERSION_C":0
|
||||
|
||||
@ -278,6 +278,10 @@ X509 CSR Information RSA-PSS with SHA512
|
||||
depends_on:MBEDTLS_PEM_PARSE_C:MBEDTLS_X509_RSASSA_PSS_SUPPORT:MBEDTLS_SHA512_C
|
||||
mbedtls_x509_csr_info:"data_files/server9.req.sha512":"CSR version \: 1\nsubject name \: C=NL, O=PolarSSL, CN=localhost\nsigned using \: RSASSA-PSS (SHA512, MGF1-SHA512, 0x3E)\nRSA key size \: 1024 bits\n"
|
||||
|
||||
X509 CSR Information RSA with SHA256 - Microsoft header
|
||||
depends_on:MBEDTLS_PEM_PARSE_C:MBEDTLS_SHA256_C:MBEDTLS_RSA_C
|
||||
mbedtls_x509_csr_info:"data_files/server1-ms.req.sha256":"CSR version \: 1\nsubject name \: C=NL, O=PolarSSL, CN=PolarSSL Server 1\nsigned using \: RSA with SHA-256\nRSA key size \: 2048 bits\n"
|
||||
|
||||
X509 Verify Information: empty
|
||||
x509_verify_info:0:"":""
|
||||
|
||||
|
||||
@ -334,6 +334,10 @@ void x509_verify( char *crt_file, char *ca_file, char *crl_file,
|
||||
char * cn_name = NULL;
|
||||
const mbedtls_x509_crt_profile *profile;
|
||||
|
||||
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
#endif
|
||||
|
||||
mbedtls_x509_crt_init( &crt );
|
||||
mbedtls_x509_crt_init( &ca );
|
||||
mbedtls_x509_crl_init( &crl );
|
||||
@ -387,6 +391,10 @@ void x509_verify_callback( char *crt_file, char *ca_file, char *name,
|
||||
uint32_t flags = 0;
|
||||
verify_print_context vrfy_ctx;
|
||||
|
||||
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
#endif
|
||||
|
||||
mbedtls_x509_crt_init( &crt );
|
||||
mbedtls_x509_crt_init( &ca );
|
||||
verify_print_init( &vrfy_ctx );
|
||||
@ -605,6 +613,10 @@ void mbedtls_x509_crt_verify_max( char *ca_file, char *chain_dir, int nb_int,
|
||||
uint32_t flags;
|
||||
mbedtls_x509_crt trusted, chain;
|
||||
|
||||
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
#endif
|
||||
|
||||
/*
|
||||
* We expect chain_dir to contain certificates 00.crt, 01.crt, etc.
|
||||
* with NN.crt signed by NN-1.crt
|
||||
@ -646,6 +658,10 @@ void mbedtls_x509_crt_verify_chain( char *chain_paths, char *trusted_ca,
|
||||
mbedtls_x509_crt trusted, chain;
|
||||
const mbedtls_x509_crt_profile *profile = NULL;
|
||||
|
||||
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
||||
TEST_ASSERT( psa_crypto_init() == 0 );
|
||||
#endif
|
||||
|
||||
mbedtls_x509_crt_init( &chain );
|
||||
mbedtls_x509_crt_init( &trusted );
|
||||
|
||||
|
||||
Reference in New Issue
Block a user