diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/__init__.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/__init__.py new file mode 100644 index 0000000..6e2b667 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/__init__.py @@ -0,0 +1,5 @@ +# +# Copyright(c) 2022 Intel Corporation +# Copyright(c) 2024 Huawei Technologies +# SPDX-License-Identifier: BSD-3-Clause +# diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_cache_id.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_cache_id.py new file mode 100644 index 0000000..f4418c8 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_cache_id.py @@ -0,0 +1,93 @@ +# +# Copyright(c) 2022 Intel Corporation +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +import pytest + +from api.cas import casadm +from api.cas.cache_config import ( + CacheMode, + CacheLineSize, + UnalignedIo, + KernelParameters, + UseIoScheduler, + CleaningPolicy, + CacheModeTrait, +) +from api.cas.cli import add_core_cmd +from core.test_run import TestRun +from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + get_fuzz_config, + run_cmd_and_validate, +) + + +@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand])) +@pytest.mark.require_disk("core", DiskTypeLowerThan("cache")) +@pytest.mark.parametrizex("cache_mode", CacheMode) +@pytest.mark.parametrizex("cache_line_size", CacheLineSize) +@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy) +@pytest.mark.parametrizex("unaligned_io", UnalignedIo) +@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler) +def test_fuzzy_add_core_cache_id( + cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler +): + """ + title: Fuzzy test for casadm 'add core' command – cache id + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong cache id in + 'add core' command. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + + core_id = 1 + + with TestRun.step("Start cache and set appropriate cleaning policy."): + cache_disk = TestRun.disks["cache"] + core_disk = TestRun.disks["core"] + cache = casadm.start_cache( + cache_dev=cache_disk, + cache_mode=cache_mode, + cache_line_size=cache_line_size, + cache_id=1, + force=True, + kernel_params=KernelParameters(unaligned_io, use_io_scheduler), + ) + + cache.set_cleaning_policy( + cleaning_policy=( + cleaning_policy + if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode) + else CleaningPolicy.DEFAULT + ) + ) + + with TestRun.step("Prepare PeachFuzzer"): + valid_values = [str(cache.cache_id).encode("ascii")] + fuzz_config = get_fuzz_config("cache_id.yml") + PeachFuzzer.generate_config(fuzz_config) + base_cmd = add_core_cmd( + cache_id="{param}", core_dev=core_disk.path, core_id=str(core_id) + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Cache id", + is_valid=cmd.param in valid_values, + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + cache.remove_core(core_id) diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_core_id.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_core_id.py new file mode 100644 index 0000000..9044ee0 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_core_id.py @@ -0,0 +1,100 @@ +# +# Copyright(c) 2022 Intel Corporation +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +import pytest + +from api.cas import casadm +from api.cas.cache_config import ( + CacheMode, + CacheLineSize, + UnalignedIo, + KernelParameters, + UseIoScheduler, + CleaningPolicy, + CacheModeTrait, +) +from api.cas.cli import add_core_cmd +from core.test_run import TestRun +from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + get_fuzz_config, + run_cmd_and_validate, +) + +core_id_min = 0 +core_id_max = 4095 + + +@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand])) +@pytest.mark.require_disk("core", DiskTypeLowerThan("cache")) +@pytest.mark.parametrizex("cache_mode", CacheMode) +@pytest.mark.parametrizex("cache_line_size", CacheLineSize) +@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy) +@pytest.mark.parametrizex("unaligned_io", UnalignedIo) +@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler) +def test_fuzzy_add_core_core_id( + cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler +): + """ + title: Fuzzy test for casadm 'add core' command – core id + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong core id in + 'add core' command. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + with TestRun.step("Start cache and set appropriate cleaning policy."): + cache_disk = TestRun.disks["cache"] + core_disk = TestRun.disks["core"] + cache = casadm.start_cache( + cache_dev=cache_disk, + cache_mode=cache_mode, + cache_line_size=cache_line_size, + cache_id=1, + force=True, + kernel_params=KernelParameters(unaligned_io, use_io_scheduler), + ) + + cache.set_cleaning_policy( + cleaning_policy=( + cleaning_policy + if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode) + else CleaningPolicy.DEFAULT + ) + ) + + with TestRun.step("Prepare PeachFuzzer"): + fuzz_config = get_fuzz_config("core_id.yml") + PeachFuzzer.generate_config(fuzz_config) + base_cmd = add_core_cmd( + cache_id=str(cache.cache_id), core_dev=core_disk.path, core_id="{param}" + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Core id", + is_valid=__is_valid(cmd.param), + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + cache.remove_core(core_id=int(cmd.param)) + + +def __is_valid(parameter): + try: + value = int(parameter) + except ValueError: + return False + return core_id_min <= value <= core_id_max diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_device.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_device.py new file mode 100644 index 0000000..2759352 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_device.py @@ -0,0 +1,98 @@ +# +# Copyright(c) 2022 Intel Corporation +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +import pytest + +from api.cas import casadm +from api.cas.cache_config import ( + CacheMode, + CacheLineSize, + UnalignedIo, + KernelParameters, + UseIoScheduler, + CleaningPolicy, + CacheModeTrait, +) +from api.cas.cli import add_core_cmd +from core.test_run import TestRun +from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + run_cmd_and_validate, + get_device_fuzz_config, +) + + +@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand])) +@pytest.mark.require_disk("core", DiskTypeLowerThan("cache")) +@pytest.mark.parametrizex("cache_mode", CacheMode) +@pytest.mark.parametrizex("cache_line_size", CacheLineSize) +@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy) +@pytest.mark.parametrizex("unaligned_io", UnalignedIo) +@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler) +def test_fuzzy_add_core_device( + cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler +): + """ + title: Fuzzy test for casadm 'add core' command – device + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong core device in + 'add core' command. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + + core_id = 1 + + with TestRun.step("Start cache and set appropriate cleaning policy."): + cache_disk = TestRun.disks["cache"] + cache = casadm.start_cache( + cache_dev=cache_disk, + cache_mode=cache_mode, + cache_line_size=cache_line_size, + cache_id=1, + force=True, + kernel_params=KernelParameters(unaligned_io, use_io_scheduler), + ) + + cache.set_cleaning_policy( + cleaning_policy=( + cleaning_policy + if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode) + else CleaningPolicy.DEFAULT + ) + ) + + with TestRun.step("Prepare PeachFuzzer"): + valid_values = [ + disk.path + for disk in TestRun.dut.disks + if disk.path != cache_disk.path + and disk.block_size.get_value() >= cache_disk.block_size.get_value() + ] + fuzz_config = get_device_fuzz_config(valid_values) + valid_values = [path.encode("ascii") for path in valid_values] + PeachFuzzer.generate_config(fuzz_config) + base_cmd = add_core_cmd( + cache_id=str(cache.cache_id), core_dev="{param}", core_id=str(core_id) + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Device path", + is_valid=cmd.param in valid_values, + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + cache.remove_core(core_id=core_id) diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_cache_id.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_cache_id.py new file mode 100644 index 0000000..77e3f3c --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_cache_id.py @@ -0,0 +1,65 @@ +# +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +import pytest + +from api.cas.cli import script_try_add_cmd, remove_detached_cmd +from core.test_run import TestRun +from storage_devices.disk import DiskTypeSet, DiskType +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + run_cmd_and_validate, + get_fuzz_config, +) + +cache_id_min = 1 +cache_id_max = pow(2, 14) + + +@pytest.mark.require_disk("core", DiskTypeSet([d for d in DiskType])) +def test_fuzzy_script_add_core_try_add_cache_id(): + """ + title: Fuzzy test for casadm script 'add core' command with try-add flag - cache id. + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong cache id + in script 'add core' command with try-add flag set. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + + with TestRun.step("Prepare PeachFuzzer"): + core_disk = TestRun.disks["core"] + fuzz_config = get_fuzz_config("cache_id.yml") + PeachFuzzer.generate_config(fuzz_config) + base_cmd = script_try_add_cmd( + cache_id="{param}", core_dev=core_disk.path, core_id="1" + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Cache id", + is_valid=__is_valid(cmd.param), + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + TestRun.executor.run_expect_success( + remove_detached_cmd(core_device=core_disk.path) + ) + + +def __is_valid(parameter): + try: + value = int(parameter) + except ValueError: + return False + return cache_id_min <= value <= cache_id_max diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_core_id.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_core_id.py new file mode 100644 index 0000000..4d9b908 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_core_id.py @@ -0,0 +1,67 @@ +# +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +import pytest + +from api.cas.cli import script_try_add_cmd, remove_detached_cmd +from core.test_run import TestRun +from storage_devices.disk import DiskTypeSet, DiskType +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + run_cmd_and_validate, + get_fuzz_config, +) + +core_id_min = 0 +core_id_max = 4095 + + +@pytest.mark.require_disk("core", DiskTypeSet([d for d in DiskType])) +def test_fuzzy_script_add_core_try_add_core_id(): + """ + title: Fuzzy test for casadm script 'add core' command with try-add flag - core id. + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong core id + in script 'add core' command with try-add flag set. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + + with TestRun.step("Prepare PeachFuzzer"): + core_disk = TestRun.disks["core"] + fuzz_config = get_fuzz_config("core_id.yml") + PeachFuzzer.generate_config(fuzz_config) + base_cmd = script_try_add_cmd( + cache_id="1", + core_dev=core_disk.path, + core_id="{param}", + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Core id", + is_valid=__is_valid(cmd.param), + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + TestRun.executor.run_expect_success( + remove_detached_cmd(core_device=core_disk.path) + ) + + +def __is_valid(parameter): + try: + value = int(parameter) + except ValueError: + return False + return core_id_min <= value <= core_id_max diff --git a/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_device.py b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_device.py new file mode 100644 index 0000000..7170ec5 --- /dev/null +++ b/test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_device.py @@ -0,0 +1,52 @@ +# +# Copyright(c) 2022 Intel Corporation +# Copyright(c) 2024 Huawei Technologies Co., Ltd. +# SPDX-License-Identifier: BSD-3-Clause +# + +from api.cas.cli import script_try_add_cmd, remove_detached_cmd +from core.test_run import TestRun +from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer +from tests.security.fuzzy.kernel.common.common import ( + run_cmd_and_validate, + get_device_fuzz_config, +) + + +def test_fuzzy_script_add_core_try_add_core_device(): + """ + title: Fuzzy test for casadm script 'add core' command - core device with try-add flag. + description: | + Using Peach Fuzzer check Open CAS ability of handling wrong core device path + in 'add core' command with try-add flag set. + pass_criteria: + - System did not crash + - Open CAS still works. + """ + + with TestRun.step("Prepare PeachFuzzer"): + valid_values = [disk.path for disk in TestRun.dut.disks] + fuzz_config = get_device_fuzz_config(valid_values) + valid_values = [path.encode("ascii") for path in valid_values] + PeachFuzzer.generate_config(fuzz_config) + base_cmd = script_try_add_cmd( + cache_id="1", core_dev="{param}", core_id="1" + ) + commands = PeachFuzzer.get_fuzzed_command( + command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count + ) + + for index, cmd in TestRun.iteration( + enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times" + ): + with TestRun.step(f"Iteration {index + 1}"): + output = run_cmd_and_validate( + cmd=cmd, + value_name="Device path", + is_valid=cmd.param in valid_values, + ) + if output.exit_code == 0: + with TestRun.step("Remove core"): + TestRun.executor.run_expect_success( + remove_detached_cmd(core_device=cmd.param.decode("ascii", "ignore")) + )