phantom/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-01-26 11:13:23 -03:00
Code Issues Projects Releases Packages Wiki Activity Actions
bitcoin/contrib/devtools/test-security-check.py

131 lines
8.2 KiB
Python
Raw Normal View History

[contrib] convert test-security-check to python3
2018-04-13 23:37:53 +08:00
#!/usr/bin/env python3
scripted-diff: Bump copyright headers -BEGIN VERIFY SCRIPT- ./contrib/devtools/copyright_header.py update ./ -END VERIFY SCRIPT- Commits of previous years: - 2021: f47dda2c58b5d8d623e0e7ff4e74bc352dfa83d7 - 2020: fa0074e2d82928016a43ca408717154a1c70a4db - 2019: aaaaad6ac95b402fe18d019d67897ced6b316ee0
2022-12-24 23:49:50 +00:00
# Copyright (c) 2015-2022 The Bitcoin Core developers
[copyright] add MIT License copyright header to remaining Python files
2016-09-11 15:32:22 -06:00
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
'''
Test script for security-check.py
'''
lint: stop ignoring LIEF imports Type stubs are now available as of 0.13.0. See https://github.com/lief-project/LIEF/issues/650.
2023-04-21 10:28:53 +01:00
import lief
test: Cleanup test files in test-{security,symbol}-check.py
2021-03-13 18:27:11 +02:00
import os
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
import subprocess
import unittest
devtools: Improve *-check.py tool detection This is important to make sure that we're not testing tools different from the one we're building with. Introduce determine_wellknown_cmd, which encapsulates how we should handle well-known tools specification (IFS splitting, env override, etc.).
2021-01-21 13:52:40 -05:00
from utils import determine_wellknown_cmd
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
def write_testcode(filename):
Explicitly specify encoding when opening text files in Python code
2018-06-12 17:49:20 +02:00
with open(filename, 'w', encoding="utf8") as f:
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
f.write('''
contrib: c++ify test stubs after switching to c++ compilers
2024-07-04 20:23:51 +00:00
#include <cstdio>
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
int main()
{
contrib: c++ify test stubs after switching to c++ compilers
2024-07-04 20:23:51 +00:00
std::printf("the quick brown fox jumps over the lazy god\\n");
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
return 0;
}
''')
test: Cleanup test files in test-{security,symbol}-check.py
2021-03-13 18:27:11 +02:00
def clean_files(source, executable):
os.remove(source)
os.remove(executable)
contrib: use env_flags in get_arch Otherwise we fail to link when trying to use lld.
2024-05-09 23:44:31 +08:00
def env_flags() -> list[str]:
test-*-check: Pass in *FLAGS and compile with them These test-*-check scripts should compile "test" binaries in a way that is as close to what autotools would do, since the goal is to make sure that if we run the *-check script, they can correctly detect flaws in binaries which are compiled by our autotools-based system. Therefore, we should emulate what happens when the binary is linked in autotools, meaning that for C binaries, we need to supply the CFLAGS, CPPFLAGS, and LDFLAGS flags in that order. Note to future developers: perhaps it'd be nice to have these test-*-check scripts be part of configure.ac to avoid having to manually replicate autoconf-like behaviour every time we find a discrepancy. Of course, that would also mean you'd have to write more m4...
2021-09-30 20:17:53 -04:00
# This should behave the same as AC_TRY_LINK, so arrange well-known flags
# in the same order as autoconf would.
#
# See the definitions for ac_link in autoconf's lib/autoconf/c.m4 file for
# reference.
contrib: use env_flags in get_arch Otherwise we fail to link when trying to use lld.
2024-05-09 23:44:31 +08:00
flags: list[str] = []
contrib: use c++ rather than c for binary tests We don't actually use a c compiler as part of Core's build (only for secp). We should be testing against what we're actually using instead.
2024-07-03 19:38:01 +00:00
for var in ['CXXFLAGS', 'CPPFLAGS', 'LDFLAGS']:
contrib: use env_flags in get_arch Otherwise we fail to link when trying to use lld.
2024-05-09 23:44:31 +08:00
flags += filter(None, os.environ.get(var, '').split(' '))
return flags
test-*-check: Pass in *FLAGS and compile with them These test-*-check scripts should compile "test" binaries in a way that is as close to what autotools would do, since the goal is to make sure that if we run the *-check script, they can correctly detect flaws in binaries which are compiled by our autotools-based system. Therefore, we should emulate what happens when the binary is linked in autotools, meaning that for C binaries, we need to supply the CFLAGS, CPPFLAGS, and LDFLAGS flags in that order. Note to future developers: perhaps it'd be nice to have these test-*-check scripts be part of configure.ac to avoid having to manually replicate autoconf-like behaviour every time we find a discrepancy. Of course, that would also mean you'd have to write more m4...
2021-09-30 20:17:53 -04:00
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
def call_security_check(cxx: str, source: str, executable: str, options) -> tuple:
subprocess.run([*cxx,source,'-o',executable] + env_flags() + options, check=True)
scripted-diff: Use new python 3.7 keywords -BEGIN VERIFY SCRIPT- sed -i 's/universal_newlines/text/g' $(git grep -l universal_newlines) -END VERIFY SCRIPT-
2023-01-17 21:46:35 +01:00
p = subprocess.run([os.path.join(os.path.dirname(__file__), 'security-check.py'), executable], stdout=subprocess.PIPE, text=True)
test: use subprocess.run() in test-security-check.py
2020-05-15 10:52:20 +08:00
return (p.returncode, p.stdout.rstrip())
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
def get_arch(cxx, source, executable):
subprocess.run([*cxx, source, '-o', executable] + env_flags(), check=True)
scripts: add CONTROL_FLOW to ELF security checks
2021-10-15 13:41:49 +08:00
binary = lief.parse(executable)
arch = binary.abstract.header.architecture
os.remove(executable)
return arch
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
class TestSecurityChecks(unittest.TestCase):
def test_ELF(self):
contrib: use c++ rather than c for binary tests We don't actually use a c compiler as part of Core's build (only for secp). We should be testing against what we're actually using instead.
2024-07-03 19:38:01 +00:00
source = 'test1.cpp'
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
executable = 'test1'
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
cxx = determine_wellknown_cmd('CXX', 'g++')
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
write_testcode(source)
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
arch = get_arch(cxx, source, executable)
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
scripts: add CONTROL_FLOW to ELF security checks
2021-10-15 13:41:49 +08:00
if arch == lief.ARCHITECTURES.X86:
contrib: test for FORTIFY_SOURCE in security-check.py
2023-02-03 16:16:56 +00:00
pass_flags = ['-D_FORTIFY_SOURCE=3', '-Wl,-znoexecstack', '-Wl,-zrelro', '-Wl,-z,now', '-pie', '-fPIE', '-Wl,-z,separate-code', '-fcf-protection=full']
contrib: simplify ELF test-security-check
2024-07-10 16:37:14 +01:00
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-zexecstack']), (1, executable + ': failed NX'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-no-pie','-fno-PIE']), (1, executable + ': failed PIE'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-znorelro']), (1, executable + ': failed RELRO'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-z,noseparate-code']), (1, executable + ': failed SEPARATE_CODE'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fcf-protection=none']), (1, executable + ': failed CONTROL_FLOW'))
contrib: test for FORTIFY_SOURCE in security-check.py
2023-02-03 16:16:56 +00:00
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-U_FORTIFY_SOURCE']), (1, executable + ': failed FORTIFY'))
contrib: simplify ELF test-security-check
2024-07-10 16:37:14 +01:00
self.assertEqual(call_security_check(cxx, source, executable, pass_flags), (0, ''))
scripts: add CONTROL_FLOW to ELF security checks
2021-10-15 13:41:49 +08:00
else:
contrib: test for FORTIFY_SOURCE in security-check.py
2023-02-03 16:16:56 +00:00
pass_flags = ['-D_FORTIFY_SOURCE=3', '-Wl,-znoexecstack', '-Wl,-zrelro', '-Wl,-z,now', '-pie', '-fPIE', '-Wl,-z,separate-code']
contrib: simplify ELF test-security-check
2024-07-10 16:37:14 +01:00
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-zexecstack']), (1, executable + ': failed NX'))
contrib: test for FORTIFY_SOURCE in security-check.py
2023-02-03 16:16:56 +00:00
# LIEF fails to parse RISC-V with no PIE correctly, and doesn't detect the fortified function,
# so skip this test for RISC-V (for now). See https://github.com/lief-project/LIEF/issues/1082.
if arch != lief.ARCHITECTURES.RISCV:
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-no-pie','-fno-PIE']), (1, executable + ': failed PIE'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-U_FORTIFY_SOURCE']), (1, executable + ': failed FORTIFY'))
contrib: simplify ELF test-security-check
2024-07-10 16:37:14 +01:00
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-znorelro']), (1, executable + ': failed RELRO'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-z,noseparate-code']), (1, executable + ': failed SEPARATE_CODE'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags), (0, ''))
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
test: Cleanup test files in test-{security,symbol}-check.py
2021-03-13 18:27:11 +02:00
clean_files(source, executable)
scripts: rename test_64bit_PE to test_PE
2020-03-26 11:37:32 +08:00
def test_PE(self):
contrib: use c++ rather than c for binary tests We don't actually use a c compiler as part of Core's build (only for secp). We should be testing against what we're actually using instead.
2024-07-03 19:38:01 +00:00
source = 'test1.cpp'
tests: Add test for 64-bit PE, modify 32-bit test results 9a75d29b6f0d6c4834e451b0fae2200786655a35 change the error result from `PIE` to `DYNAMIC_BASE`. And there are no test for 64-bit, so I made one
2018-04-27 00:43:01 +08:00
executable = 'test1.exe'
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
cxx = determine_wellknown_cmd('CXX', 'x86_64-w64-mingw32-g++')
tests: Add test for 64-bit PE, modify 32-bit test results 9a75d29b6f0d6c4834e451b0fae2200786655a35 change the error result from `PIE` to `DYNAMIC_BASE`. And there are no test for 64-bit, so I made one
2018-04-27 00:43:01 +08:00
write_testcode(source)
contrib: simplify PE test-security-check
2024-07-10 16:17:21 +01:00
pass_flags = ['-Wl,--nxcompat', '-Wl,--enable-reloc-section', '-Wl,--dynamicbase', '-Wl,--high-entropy-va', '-pie', '-fPIE', '-fcf-protection=full', '-fstack-protector-all', '-lssp']
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fno-stack-protector']), (1, executable + ': failed CANARY'))
# https://github.com/lief-project/LIEF/issues/1076 - in future, we could test this individually.
# self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,--disable-reloc-section']), (1, executable + ': failed RELOC_SECTION'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,--disable-nxcompat']), (1, executable + ': failed NX'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,--disable-dynamicbase']), (1, executable + ': failed PIE DYNAMIC_BASE HIGH_ENTROPY_VA')) # -pie -fPIE does nothing without --dynamicbase
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,--disable-high-entropy-va']), (1, executable + ': failed HIGH_ENTROPY_VA'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fcf-protection=none']), (1, executable + ': failed CONTROL_FLOW'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags), (0, ''))
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
test: Cleanup test files in test-{security,symbol}-check.py
2021-03-13 18:27:11 +02:00
clean_files(source, executable)
scripts: add MACHO tests to test-security-check.py
2020-03-24 12:37:57 +08:00
def test_MACHO(self):
contrib: use c++ rather than c for binary tests We don't actually use a c compiler as part of Core's build (only for secp). We should be testing against what we're actually using instead.
2024-07-03 19:38:01 +00:00
source = 'test1.cpp'
scripts: add MACHO tests to test-security-check.py
2020-03-24 12:37:57 +08:00
executable = 'test1'
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
cxx = determine_wellknown_cmd('CXX', 'clang++')
scripts: add MACHO tests to test-security-check.py
2020-03-24 12:37:57 +08:00
write_testcode(source)
contrib: rename cc to cxx in binary checking scripts
2024-07-03 19:41:12 +00:00
arch = get_arch(cxx, source, executable)
contrib: support arm64 darwin in security checks
2022-01-11 21:18:24 +08:00
if arch == lief.ARCHITECTURES.X86:
contrib: simplify MACHO test-security-check
2024-07-10 15:46:55 +01:00
pass_flags = ['-Wl,-pie', '-fstack-protector-all', '-fcf-protection=full', '-Wl,-fixup_chains']
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-no_pie', '-Wl,-no_fixup_chains']), (1, executable+': failed FIXUP_CHAINS PIE')) # -fixup_chains is incompatible with -no_pie
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-no_fixup_chains']), (1, executable + ': failed FIXUP_CHAINS'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fno-stack-protector']), (1, executable + ': failed CANARY'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-flat_namespace']), (1, executable + ': failed NOUNDEFS'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fcf-protection=none']), (1, executable + ': failed CONTROL_FLOW'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags), (0, ''))
contrib: support arm64 darwin in security checks
2022-01-11 21:18:24 +08:00
else:
contrib: simplify MACHO test-security-check
2024-07-10 15:46:55 +01:00
# arm64 darwin doesn't support non-PIE binaries or executable stacks
pass_flags = ['-fstack-protector-all', '-Wl,-fixup_chains', '-mbranch-protection=bti']
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-mbranch-protection=none']), (1, executable + ': failed BRANCH_PROTECTION'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-no_fixup_chains']), (1, executable + ': failed FIXUP_CHAINS'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-fno-stack-protector']), (1, executable + ': failed CANARY'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags + ['-Wl,-flat_namespace']), (1, executable + ': failed NOUNDEFS'))
self.assertEqual(call_security_check(cxx, source, executable, pass_flags), (0, ''))
scripts: add MACHO tests to test-security-check.py
2020-03-24 12:37:57 +08:00
test: Cleanup test files in test-{security,symbol}-check.py
2021-03-13 18:27:11 +02:00
clean_files(source, executable)
devtools: Add security-check.py Perform the following ELF security checks: - PIE: Check for position independent executable (PIE), allowing for address space randomization - NX: Check that no sections are writable and executable (including the stack) - RELRO: Check for read-only relocations, binding at startup - Canary: Check for use of stack canary Also add a check to symbol-check.py that checks that only the subset of allowed libraries is imported (to avoid incompatibilities).
2015-10-19 14:53:56 +02:00
if __name__ == '__main__':
unittest.main()
Reference in a new issue Copy permalink