flextool
1.0.0
Uma solução poderosa totalmente aberta para modificação e geração de código -fonte C ++. Reduza a quantidade de código de caldeira em seus projetos C ++.
Página do projeto principal: https://blockspacer.github.io/flex_docs/
Testado no Ubuntu 20.04.2 LTS.
Pode trabalhar em outras plataformas com pequenas modificações.
Para poder adicionar a lista de controles remotos de dependência, digite o seguinte comando:
cmake -E time conan config install conan/remotes/
# OR:
# cmake -E time conan config install conan/remotes_disabled_ssl/ Guia de instalação
Pacotes Conan
NOTA: O apelo com a construção do LLVM pode levar algumas horas.
O comando abaixo usa --profile clang12_compiler12_compiler .
Exemplo de Conan perfil ~/.conan/profiles/clang :
[ settings ]
# We are building in Ubuntu Linux
os_build=Linux
os=Linux
arch_build=x86_64
arch=x86_64
compiler=clang
compiler.version=10
compiler.libcxx=libstdc++11
[ env ]
CC=/usr/bin/clang-10
CXX=/usr/bin/clang++-10
[ build_requires ]
cmake_installer/3.15.5@conan/stableCriar perfil de clang12_compiler:
[settings]
# We are building in Ubuntu Linux
os_build=Linux
os=Linux
arch_build=x86_64
arch=x86_64
compiler=clang
compiler.version=12
compiler.libcxx=libstdc++11
compiler.cppstd=17
llvm_9:build_type=Release
[env]
CC=/usr/bin/clang-12
CXX=/usr/bin/clang++-12
[build_requires]
cmake_installer/3.15.5@conan/stableAntes da criação do arquivo de perfil Conan, consulte: https://docs.conan.io/en/latest/using_packages/using_profiles.html.
Usamos o script .cmake para baixar e instalar pacotes Conan.
git clone https://github.com/blockspacer/conan_github_downloader.git ~ /conan_github_downloader
cmake
-DSCRIPT_PATH= " $PWD /get_conan_dependencies.cmake "
-DENABLE_CLING=TRUE
-DENABLE_LLVM=TRUE
-DENABLE_LLVM_INSTALLER=FALSE
-DEXTRA_CONAN_OPTS= " --profile;clang12_compiler
;-s;build_type=Debug
;-s;cling_conan:build_type=Release
;-s;llvm_12:build_type=Release
;--build;missing "
-P ~ /conan_github_downloader/conan_github_downloader.cmake
# clean build cache
conan remove " * " --build --force Se você deseja instalar o Flextool e seus plugins no comando único, altere as opções fornecidas para tools/buildConanThirdparty.cmake .
NOTA: tools/buildConanThirdparty.cmake executará uma reconstrução completa; Pode levar duas horas.
O comando abaixo usa --profile clang12_compiler12_compiler . Antes da criação do arquivo de perfil Conan, consulte: https://docs.conan.io/en/latest/using_packages/using_profiles.html.
Usamos o script buildConanThirdparty.cmake para baixar e instalar pacotes Conan.
Nota: set -DENABLE_CLING=FALSE se você já instalou o apelido usando tools/buildConanThirdparty.cmake acima.
git clone https://github.com/blockspacer/conan_github_downloader.git ~ /conan_github_downloader
cmake
-DSCRIPT_PATH= " $PWD /get_conan_dependencies.cmake "
-DENABLE_CLING=TRUE
-DENABLE_LLVM=TRUE
-DENABLE_LLVM_INSTALLER=FALSE
-DENABLE_FLEXTOOL=TRUE
-DENABLE_BASIS_PLUGIN_HELPER=TRUE
-DENABLE_FLEX_REFLECT_PLUGIN=TRUE
-DENABLE_SQUARETS=TRUE
-DENABLE_FLEX_SQUARETS_PLUGIN=TRUE
-DENABLE_FLEX_PIMPL_PLUGIN=TRUE
-DENABLE_FLEX_TYPECLASS_PLUGIN=TRUE
-DENABLE_FLEX_META_PLUGIN=TRUE
-DENABLE_FLEX_META_DEMO=TRUE
-DEXTRA_CONAN_OPTS= " --profile;clang12_compiler
;-s;build_type=Debug
;-s;cling_conan:build_type=Release
;-s;llvm_12:build_type=Release
;--build;missing "
-P ~ /conan_github_downloader/conan_github_downloader.cmake
# clean build cache
conan remove " * " --build --forceUse o comando abaixo para reconstruir o flextool (os plug-ins devem ser instalados separadamente).
O comando abaixo usa --profile clang12_compiler12_compiler . Antes da criação do arquivo de perfil Conan, consulte: https://docs.conan.io/en/latest/using_packages/using_profiles.html
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
# NOTE: change `build_type=Debug` to `build_type=Release` in production
# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time
conan create . conan/stable
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
--profile clang12_compiler
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
# clean build cache
conan remove " * " --build --forcecompile_commands.jsonDesative a geração de banco de dados de compilação ao usar o Flextool.
Se você estiver usando cmake, defina CMAKE_EXPORT_COMPILE_COMMANDS como FALSE .
Se compile_commands.json existir na pasta Build (ou na pasta pai), o Flextool poderá falhar.
Este projeto é possível devido ao autoprogrammer do Flexferrum.
Artigos sobre autoprogrammer da Flexferrum na mídia:
find . -type f -name " *_buildflags.h " -exec rm {} ;
find . -type f -name " *_buildflags.tmp " -exec rm {} ;
(rm -rf local_build || true)
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
export PKG_NAME=flextool/master@conan/stable
(CONAN_REVISIONS_ENABLED=1
conan remove --force $PKG_NAME || true)
# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time
conan install .
--install-folder local_build
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_12:build_type=Release
-o openssl:shared=True
-e basis:enable_tests=True
-o chromium_base:shared=True
-e chromium_base:enable_tests=True
-o perfetto:is_hermetic_clang=False
--profile clang12_compiler
-e flexlib:enable_tests=True
-o flexlib:shared=False
-o perfetto:is_hermetic_clang=False
-o flexlib:enable_cling=True
-e flextool:enable_tests=True
-o flextool:enable_cling=True
(rm local_build/CMakeCache.txt || true)
cmake -E time
conan source .
--source-folder .
--install-folder local_build
# You can use `cmake --build . -- -j14` on second run.
cmake -E time
conan build .
--build-folder local_build
--source-folder .
--install-folder local_build
conan package .
--build-folder local_build
--package-folder local_build/package_dir
--source-folder .
--install-folder local_build
cmake -E time
conan export-pkg . conan/stable
--package-folder local_build/package_dir
-s build_type=Debug
--force
-s cling_conan:build_type=Release
-s llvm_12:build_type=Release
-o openssl:shared=True
-e basis:enable_tests=True
-o chromium_base:shared=True
-e chromium_base:enable_tests=True
-o perfetto:is_hermetic_clang=False
--profile clang12_compiler
-e flexlib:enable_tests=True
-o flexlib:shared=False
-o perfetto:is_hermetic_clang=False
-o flexlib:enable_cling=True
-e flextool:enable_tests=True
-o flextool:enable_cling=True
cmake -E time
conan test test_package
flextool/master@conan/stable
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_12:build_type=Release
-o openssl:shared=True
-e basis:enable_tests=True
-o chromium_base:shared=True
-e chromium_base:enable_tests=True
-o perfetto:is_hermetic_clang=False
--profile clang12_compiler
-e flexlib:enable_tests=True
-o flexlib:shared=False
-o perfetto:is_hermetic_clang=False
-o flexlib:enable_cling=True
-e flextool:enable_tests=True
-o flextool:enable_cling=True Com os pacotes editáveis, você pode dizer a Conan onde encontrar os cabeçalhos e os artefatos prontos para o consumo no diretório de trabalho local. Não há necessidade de executar conan create ou conan export-pkg .
Para detalhes, consulte: https://docs.conan.io/en/latest/developing_packages/editable_packages.html
Construir localmente:
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
cmake -E time
conan install .
--install-folder local_build
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
--profile clang12_compiler
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
cmake -E time
conan source .
--source-folder local_build
--install-folder local_build
conan build .
--build-folder local_build
--source-folder local_build
--install-folder local_build
conan package .
--build-folder local_build
--package-folder local_build/package_dir
--source-folder local_build
--install-folder local_buildDefina o pacote para o modo editável:
conan editable add local_build/package_dir
flextool/master@conan/stable Observe que conanfile.py é modificado para detectar construções locais via self.in_local_cache .
Após a mudança, a fonte na pasta local_build (comandos de execução na pasta do pacote de origem):
conan build .
--build-folder local_build
--source-folder local_build
--install-folder local_build
conan package .
--build-folder local_build
--package-folder local_build/package_dir
--source-folder local_build
--install-folder local_build
Crie seu projeto de teste.
Para reverter o modo editável, basta remover o link usando:
conan editable remove
flextool/master@conan/stable Permite construir vários projetos de uma só vez; Ele apenas cria CMakeLists.txt com add_subdirectory apontando para cada pasta de pacotes.
NOTA: Você pode abrir espaço de trabalho no IDE, como de costume, projeto baseado em cmakes (Diretório de Builsão de Alterar para o WorkspaceProject Path)!
Para detalhes, consulte: https://docs.conan.io/en/latest/developing_packages/workspaces.html
Por exemplo, queremos criar o Flextool e o Flexlib ao mesmo tempo (o Flextool requer Flexlib).
# change ~ to desired build folder
cd ~
# Replace paths to yours!
# Make sure each project in NOT in editable mode!
cat << EOF > ~/conanws.yml
editables:
flexlib/master@conan/stable:
path: /......../flexlib
flextool/master@conan/stable:
path: /......../flextool
layout: layout_flex
workspace_generator: cmake
root:
- flextool/master@conan/stable
EOF
cat << EOF > ~/layout_flex
# This helps to define the location of CMakeLists.txt within package
[source_folder]
.
# This defines where the conanbuildinfo.cmake will be written to
[build_folder]
build/{{settings.build_type}}
EOF mkdir build_flex
cd build_flex
cat << EOF > CMakeLists.txt
cmake_minimum_required(VERSION 3.0)
project(WorkspaceProject)
include( $ {CMAKE_BINARY_DIR}/conanworkspace.cmake)
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flexlib_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flextool_SRC}/cmake")
conan_workspace_subdirectories()
add_dependencies(flextool flexlib)
EOF
# must contain `include(${CMAKE_BINARY_DIR}/conanworkspace.cmake)` without slash `` (slash added for bash cat command)
cat CMakeLists.txt
# combines options from all projects
conan workspace install
../conanws.yml
--profile=clang
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
-o openssl:shared=True
-o chromium_base:shared=True
-e basis:enable_tests=True
-e abseil:enable_llvm_tools=True
-o chromium_base:use_alloc_shim=True
-o chromium_tcmalloc:use_alloc_shim=True
-o perfetto:is_hermetic_clang=False
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
-o flexlib:shared=False
-o flexlib:enable_clang_from_conan=False
-e flexlib:enable_tests=True Construa na pasta criada por conan workspace install :
# NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug
# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)
# configure via cmake
cmake -E time cmake .
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DENABLE_TESTS=TRUE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=ON
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE= ${build_type}
# remove generated files
# change paths to yours
# rm ~/flex_typeclass_plugin/build/Debug/*generated*
# build code
cmake -E time cmake --build .
--config ${build_type}
-- -j8
# run unit tests for flexlib
cmake -E time cmake --build .
--config ${build_type}
--target flexlib_run_all_tests
# run unit tests for flextool
cmake -E time cmake --build .
--config ${build_type}
--target flextool_run_all_testsO espaço de trabalho permite fazer alterações rápidas nos arquivos de origem existentes.
Usamos self.in_local_cache para detectar o modo editável Conan:
# Local build
# see https://docs.conan.io/en/latest/developing_packages/editable_packages.html
if not self . in_local_cache :
self . copy ( "conanfile.py" , dst = "." , keep_path = False )Certifique -se de que todos os alvos tenham nomes globalmente únicos.
Por exemplo: você não pode ter um alvo em cada projeto com o mesmo nome como "teste". Você pode resolver esse problema adicionando prefixo específico do projeto ao nome de cada destino como "$ {root_project_name} -test_main_gtest".
Como CMAKE_BINARY_DIR apontará para a pasta criada pelo conan workspace install , certifique -se de preferir CMAKE_CURRENT_BINARY_DIR a CMAKE_BINARY_DIR etc.
Antes da instalação: os plugins requerem Flextool pré-construído (na mesma área de trabalho). Você deve criar espaço de trabalho sem plugins; Só então você poderá reconstruí-lo com plugins.
Adicione plugins ao arquivo YML:
editables :
chromium_base/master@conan/stable :
path : /........./chromium_base
basis/master@conan/stable :
path : /........./basis
flex_support_headers/master@conan/stable :
path : /........./flex_support_headers
flexlib/master@conan/stable :
path : /........./flexlib
flextool/master@conan/stable :
path : /........./flextool
flex_reflect_plugin/master@conan/stable :
path : /........./flex_reflect_plugin
squarets/master@conan/stable :
path : /........./squarets
flex_squarets_plugin/master@conan/stable :
path : /........./flex_squarets_plugin
flex_typeclass_plugin/master@conan/stable :
path : /........./flex_typeclass_plugin
flex_pimpl_plugin/master@conan/stable :
path : /........./flex_pimpl_plugin
flex_meta_plugin/master@conan/stable :
path : /........./flex_meta_plugin
flex_meta_demo/master@conan/stable :
path : /........./flex_meta_demo
layout : layout_flex
workspace_generator : cmake
root :
- flex_reflect_plugin/master@conan/stable
- squarets/master@conan/stable
- flex_squarets_plugin/master@conan/stable
- flex_typeclass_plugin/master@conan/stable
- flex_pimpl_plugin/master@conan/stable
- flex_meta_plugin/master@conan/stable
- flex_meta_demo/master@conan/stable Use add_dependencies em CMakeLists.txt :
mkdir build_flex
cd build_flex
cat << EOF > CMakeLists.txt
cmake_minimum_required(VERSION 3.0)
project(WorkspaceProject)
include( $ {CMAKE_BINARY_DIR}/conanworkspace.cmake)
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_chromium_base_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_basis_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_support_headers_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flexlib_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_reflect_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_squarets_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_squarets_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_typeclass_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_meta_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_meta_demo_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_pimpl_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flextool_SRC}/cmake")
conan_workspace_subdirectories()
add_dependencies(basis chromium_base-static)
add_dependencies(flexlib basis)
add_dependencies(flextool flexlib basis flex_support_headers)
add_dependencies(flex_reflect_plugin flextool)
add_dependencies(flex_squarets_plugin squarets)
add_dependencies(flex_squarets_plugin flextool)
add_dependencies(flex_pimpl_plugin flextool)
add_dependencies(flex_pimpl_plugin flex_reflect_plugin)
add_dependencies(flex_pimpl_plugin flex_squarets_plugin)
add_dependencies(flex_typeclass_plugin flextool)
add_dependencies(flex_typeclass_plugin flex_squarets_plugin)
add_dependencies(flex_meta_demo flex_meta_plugin)
add_dependencies(flex_meta_demo flex_typeclass_plugin)
add_dependencies(flex_meta_demo flex_pimpl_plugin)
add_dependencies(flex_meta_demo flex_squarets_plugin)
EOF Adicionar opções de plug -ins à conan workspace install :
# combines options from all projects
conan workspace install
../conanws.yml
--profile=clang
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
-e basis:enable_tests=True
-o openssl:shared=True
-o chromium_base:shared=True
-o chromium_base:use_alloc_shim=True
-o perfetto:is_hermetic_clang=False
-o chromium_tcmalloc:use_alloc_shim=True
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
-o flexlib:shared=False
-o flexlib:enable_clang_from_conan=False
-e flexlib:enable_tests=True
-o flex_reflect_plugin:shared=True
-o flex_reflect_plugin:enable_clang_from_conan=False
-e flex_reflect_plugin:enable_tests=True
-o squarets:shared=False
-o squarets:enable_clang_from_conan=False
-e squarets:enable_tests=True
-o flex_squarets_plugin:shared=False
-o flex_squarets_plugin:enable_clang_from_conan=False
-e flex_squarets_plugin:enable_tests=True
-o flex_meta_plugin:shared=False
-o flex_meta_plugin:enable_clang_from_conan=False
-e flex_meta_plugin:enable_tests=True
-o flex_typeclass_plugin:shared=False
-o flex_typeclass_plugin:enable_clang_from_conan=False
-e flex_typeclass_plugin:enable_tests=True
-o flex_pimpl_plugin:shared=False
-o flex_pimpl_plugin:enable_clang_from_conan=False
-e flex_pimpl_plugin:enable_tests=True
-o flex_meta_demo:enable_clang_from_conan=False
-e flex_meta_demo:enable_tests=TrueConstruir e testar espaço de trabalho:
# NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug
# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)
# configure via cmake
cmake -E time cmake .
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DENABLE_TESTS=TRUE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=ON
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE= ${build_type}
# remove generated files
# change paths to yours
# rm ~/flex_typeclass_plugin/build/Debug/*generated*
# build code
cmake -E time cmake --build .
--config ${build_type}
-- -j8
# run unit tests for flexlib
cmake -E time cmake --build .
--config ${build_type}
--target flexlib_run_all_tests
# run unit tests for flextool
cmake -E time cmake --build .
--config ${build_type}
--target flextool_run_all_tests
# run unit tests for flex_reflect_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_reflect_plugin_run_all_tests
# run unit tests for squarets
cmake -E time cmake --build .
--config ${build_type}
--target squarets_run_all_tests
# run unit tests for flex_squarets_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_squarets_plugin_run_all_tests
# run unit tests for flex_squarets_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_meta_plugin_run_all_tests
# run unit tests for flex_squarets_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_typeclass_plugin_run_all_tests
# run unit tests for flex_squarets_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_pimpl_plugin_run_all_tests
# run unit tests for flex_squarets_plugin
cmake -E time cmake --build .
--config ${build_type}
--target flex_meta_demo_run_all_tests Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True .
Instale o cppcheck via Conan:
cd /tmp
git clone -b testing/1.90 https://github.com/bincrafters/conan-cppcheck_installer.git
cd conan-cppcheck_installer
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
# NOTE: change `build_type=Debug` to `build_type=Release` in production
# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time
conan create . conan/stable
-s build_type=Release
# clean build cache
conan remove " * " --build --force Uso (executa o cmake com -DENABLE_CPPCHECK=ON ):
# creates local build in separate folder and runs cmake targets
# NOTE: -DCLEAN_OLD="OFF" to keep generated html report
cmake -DCPPCHECK= " ON " -DCLEAN_OLD= " OFF " -P tools/run_tool.cmake # `index.html` must exist
# find $PWD -name index.htmlOpen 'index.html' para ver os resultados.
Aplicativo de desktop que fornece um único contexto para gerenciar e executar vários scripts.
Simplifica a configuração do ambiente de desenvolvimento local; Isso evita abrir muitos terminais de concha.
Você pode adicionar comandos personalizados no package.json ou plugin/vue-cli-plugin/ui.js :
# Before: Install Latest Node.js and NPM
# see https://tecadmin.net/install-latest-nodejs-npm-on-ubuntu/
node --version
npm --versionCrie seu projeto via NPM:
npm installsudo npm install -g @vue/cli
sudo vue ui --dev --port 8061 Aberto http://localhost:8061/ .
Diretório de projeto de importação.
Selecione Tasks , como Build/Test ...
As tarefas podem ser alteradas no package.json .
Nota: Usamos package.json apenas para tarefas. Conan é controlado por um arquivo chamado Conanfile.txt.
Links úteis:
Utilizamos .gdbinit adicione 'add-auto-carga-segura-path'.
Para mais detalhes sobre .gdbinit , leia: https://metricpanda.com/tips-for-produtive-debugging-with- gdb
Para mais detalhes sobre gdb , leia: http://www.yolinux.com/tutorials/gdb-commands.html
A sessão de depuração do GDB pode ser automatizada assim:
# see https://gist.github.com/williballenthin/8bd6e29ad8504b9cb308039f675ee889
gdb
-ex " run "
-ex " set pagination off "
-ex " bt "
-ex " set confirm off "
-ex " quit "
--args
${APP_EXE}
${APP_CMD_ARGS} Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True .
Para detalhes, consulte:
Instale Valgrind:
sudo apt install valgrind # Ubuntu, Debian, etc.
# OR
sudo yum install valgrind # RHEL, CentOS, Fedora, etc. Nota: certifique -se de definir use_alloc_shim=False e enable_valgrind=True (veja abaixo).
Execute Valgrind via cmake:
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
# NOTE: set `use_alloc_shim=False` and `enable_valgrind=True` for valgrind support
cmake -E time
conan install .
--install-folder local_build_valgrind
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
--profile clang12_compiler
-o flextool:enable_valgrind=True
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
-e abseil:enable_llvm_tools=True
-o chromium_base:enable_valgrind=True
-e chromium_base:enable_llvm_tools=True
-o chromium_base:use_alloc_shim=False
-o perfetto:is_hermetic_clang=False
-o basis:enable_valgrind=True
-e basis:enable_llvm_tools=True
-o flexlib:enable_valgrind=True
-e flexlib:enable_llvm_tools=True
-o flexlib:enable_clang_from_conan=False
-o chromium_tcmalloc:use_alloc_shim=False
--build chromium_base
--build chromium_tcmalloc
--build basis
--build flexlib
cd ~ /flextool
# see section about `conan editable mode`
cd local_build_valgrind
# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)
# remove old build artifacts
rm -rf flextool
rm -rf bin
find . -iname ' *.o ' -exec rm {} ;
find . -iname ' *.a ' -exec rm {} ;
find . -iname ' *.dll ' -exec rm {} ;
find . -iname ' *.lib ' -exec rm {} ;
# NOTE: -DENABLE_VALGRIND=ON
cmake ..
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DENABLE_VALGRIND=ON
-DENABLE_TESTS=TRUE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=ON
-DENABLE_VALGRIND_TESTS=TRUE
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE=Debug
# NOTE: to run some tests under valgrind
# use `-DENABLE_VALGRIND_TESTS=TRUE`
cmake -E time cmake --build .
--target flextool-gmock_run_valgrind
# Cmake will print valgrind command that was executed.
# You can copy executed command and add custom command-line arguments:
# --gtest_filter=ToolsSanityTest.DISABLED_ValgrindTest
# --gtest_also_run_disabled_tests
# search for valgrind log file
find $PWD -name * valgrind * .log Para encontrar vazamentos, você pode desviar -se definitely lost no arquivo de log.
NOTA: Você pode adicionar supressões Valgrind em cmake/valgrind.cfg .
NOTA: Compile o programa com um sinalizador de depuração para executar em Valgrind.
NOTA: Use valgrind --tool=helgrind para detectar possíveis deadlocks e corridas de dados.
NOTA: Use valgrind --tool=massif --massif-out-file=massif_file --stacks=true para medir o tamanho da pilha. Veja também: https://kde.org/applications/development/org.kde.massif-visualizer
Para detalhes, consulte: https://stackoverflow.com/a/44989219
TODO: Tente construir com Valgrind e Clang 10 https://stackoverflow.com/questions/40509986/valgrind-reporting-mismatched free-delete-delete
TODO: Valgrind pode não suportar a base de cromo, FixMe. E remova gtest_no_suite
Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True
Instale o Clang-Tidy:
sudo apt-get install clang-tidy # Ubuntu, Debian, etc.
# OR
sudo yum install clang-tidy # RHEL, CentOS, Fedora, etc. Uso (executa o cmake com -DENABLE_CLANG_TIDY=ON ):
# creates local build in separate folder and runs cmake targets
cmake -DCLANG_TIDY= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True
Para detalhes, consulte: https://chromium.googlesource.com/chromium/src.git/+/master/docs/clang_static_analyzer.md e https://clang-analyzer.llvm.org/scan-build.html
O programa CCC-analisador atua como um compilador falso, encaminhando seus argumentos na linha de comando ao compilador para executar compilação regular e clang para realizar análises estáticas.
A configuração em execução normalmente gerafiles que têm caminhos conectados para o compilador e, executando a configuração através do Scan-Build, esse caminho é definido como analisador do CCC.
# must exist
ccc-analyzer -v
# must exist
c++-analyzer -v
# must exist
scan-build -v
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
cmake -E time
conan install .
--install-folder local_build_scan_build
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
--profile clang12_compiler
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
cmake -E time
conan source .
--source-folder local_build_scan_build
--install-folder local_build_scan_build
# see section about `conan editable mode`
cd local_build_scan_build
# NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug
# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)
# NOTE: changed CMAKE_C_COMPILER to ccc-analyzer (!!!)
# configure via cmake
scan-build
--use-cc=clang-10
--use-c++=clang++-10
-o ./scanbuildout/
cmake ..
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DCMAKE_C_COMPILER=ccc-analyzer
-DCMAKE_CXX_COMPILER=c++-analyzer
-DENABLE_TESTS=FALSE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=OFF
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE= ${build_type}
# remove old build artifacts
(make clean || true)
rm -rf bin
# NOTE: requires project configured in debug build
# disable other static analyzers
# run from build directory
scan-build
-maxloop 8
-enable-checker alpha.security.taint.TaintPropagation
-enable-checker alpha.core.BoolAssignment
-enable-checker alpha.core.CastSize
-enable-checker alpha.core.DynamicTypeChecker
-enable-checker alpha.core.FixedAddr
-enable-checker alpha.core.IdenticalExpr
-enable-checker alpha.core.PointerArithm
-enable-checker alpha.core.PointerSub
-enable-checker alpha.core.SizeofPtr
-enable-checker alpha.core.TestAfterDivZero
-enable-checker alpha.deadcode.UnreachableCode
-enable-checker alpha.security.ArrayBoundV2
-enable-checker alpha.security.MallocOverflow
-enable-checker alpha.security.ReturnPtrRange
-enable-checker alpha.unix.PthreadLock
-enable-checker alpha.unix.Stream
-enable-checker alpha.unix.cstring.BufferOverlap
-enable-checker alpha.unix.cstring.NotNullTerminated
-enable-checker alpha.unix.cstring.OutOfBounds
-enable-checker nullability.NullableDereferenced
-enable-checker optin.performance.Padding
-enable-checker security.insecureAPI.rand
-enable-checker security.insecureAPI.strcpy
--use-cc=clang-10
--use-c++=clang++-10
-o ./scanbuildout/
make
-j8 Abra o arquivo scanbuildout/...../index.html
Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True
Para detalhes, consulte: https://github.com/myint/cppclean
Instalação:
pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org --upgrade cppclean Uso (executa o cmake com -DENABLE_CPPCLEAN=ON ):
# creates local build in separate folder and runs cmake targets
cmake -DCPPCLEAN= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Nota: O CPPCLEAN exige que a codificação de arquivos seja: UTF-8 without BOM (ASCII)
Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True
Incluir o que você usa (Iwyu) é um projeto destinado a otimizar inclui.
Ele calculará os cabeçalhos necessários e adicionará / removerá, conforme apropriado.
Para detalhes, consulte: https://include-what-you-use.org/
Uso (executa o cmake com -DENABLE_IWYU=ON ):
# creates local build in separate folder and runs cmake targets
cmake -DIWYU= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Codestyle: use // IWYU pragma: associated aos arquivos de origem C ++.
Nota: Leia sobre Iwyu Pragmas: https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/iwyupragmas.md
Nota: Não use "bits/" ou "/detalhes/*" inclui, adicione -os ao arquivo de mapeamentos (.imp)
Para detalhes, consulte:
Use -DUSE_CCACHE=ON
gcc -v
export CC=gcc
export CXX=g++
# NOTE: -DUSE_CCACHE=ON
cmake ..
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DUSE_CCACHE=ON
-DENABLE_TESTS=FALSE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=OFF
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE=DebugPara detalhes, consulte: https://www.virag.si/2015/07/use-ccache-with-cmake-for-faster-compilation/
Para tirar o máximo proveito do ccache, coloque algo assim em: ~/.ccache/ccache.conf :
max_size = 50.0G # or whatever cache size you prefer; default is 5G; 0 means unlimited
base_dir = /home/yourname # or wherever you keep your source files Nota: base_dir é necessário para que o CCACE compartilhe compilos em cache do mesmo arquivo em diferentes repositórios / caminhos; Ele fará isso apenas por caminhos sob base_dir . Portanto, esta opção é necessária para o uso eficaz do ccache com as árvores de trabalho Git (descritas abaixo).
Você não deve definir base_dir como "/", ou em qualquer lugar que contenha cabeçalhos do sistema (de acordo com os documentos do CCACHE).
Instalação:
sudo apt-get install ccache
# On OS X use homebrew:
# brew install ccache
ccache --version Use -DUSE_LD_GOLD=ON
gcc -v
export CC=gcc
export CXX=g++
# NOTE: -DUSE_LD_GOLD=ON
cmake ..
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DUSE_LD_GOLD=ON
-DENABLE_TESTS=FALSE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=OFF
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE=DebugPara detalhes, consulte: https://cristianadam.eu/20170709/speeding up-cmake/
NOTA: O ouro não roscado por padrão, configure com "--enable-threads"
NOTA: LLD rosqueado por padrão, pode ser mais rápido que o ouro
Certifique -se de usar Debug Build com -e flextool:enable_llvm_tools=True
Para detalhes, consulte: https://oclint-docs.readthedocs.io/en/stable/devel/codingstandards.html
Instalação:
cd ~
wget --no-check-certificate https://github.com/oclint/oclint/releases/download/v0.13.1/oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
# mirror 1: http://github.strcpy.cn/oclint/oclint/releases/download/v0.13.1/oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
# mirror 2: http://archives.oclint.org/releases/0.8/oclint-0.8.1-x86_64-linux-3.13.0-35-generic.tar.gz
tar -xzvf oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
rm -rf oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
export OCLINT_HOME= ~ /oclint-0.13.1
export PATH= $OCLINT_HOME /bin: $PATH
oclint -version Uso (executa o cmake com -DENABLE_OCLINT=ON ):
# NOTE: -DCLEAN_OLD="OFF" to keep generated html report
# creates local build in separate folder and runs cmake targets
cmake -DOCLINT= " ON " -DCLEAN_OLD= " OFF " -P tools/run_tool.cmake # `report.html` must exist
# find $PWD -name report.htmlOpen Report.html
Veja Oclint Tutorial: http://docs.oclint.org/en/stable/intro/tutorial.html
Veja a lista de regras da OCLINT em: https://oclint-docs.readthedocs.io/en/stable/rules/
NOTA: Você pode suprimir avisos de oclint http://docs.oclint.org/en/stable/howto/suppress.html#oclint-comment
Para detalhes, consulte: https://clang.llvm.org/docs/clangformat.html
Uso (executa o cmake com -DENABLE_CLANG_FORMAT=ON ):
# creates local build in separate folder and runs cmake targets
cmake -DCLANG_FORMAT= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Usamos o arquivo .clang-format . Para detalhes, consulte: https://clang.llvm.org/docs/clangformatstyleoptions.html
NOTA: Usamos DisableFormat , portanto, o formato de clang será alterado apenas incluir a ordem com base em SortIncludes .
Infelizmente, clang-format não é configurável o suficiente, por isso pode ser usado apenas para classificar. Veja: https://stackoverflow.com/a/32191189
Utilizamos Uncrustify Bacause Clang-Format e ASTYLE não suportam muitas opções.
Para detalhes, consulte: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html
Instalação:
cd ~
git clone https://github.com/uncrustify/uncrustify.git
cd uncrustify
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .
export UNCRUSTIFY_HOME= ~ /uncrustify/build
export PATH= $UNCRUSTIFY_HOME : $PATH
# OR sudo make install
uncrustify --version Uso (executa o cmake com -DENABLE_UNCRUSTIFY=ON ):
# creates local build in separate folder and runs cmake targets
cmake -DUNCRUSTIFY= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Usamos o arquivo uncrustify.cfg . Para detalhes, consulte: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html
Para obter uma lista de todas as opções disponíveis, use:
uncrustify --show-configA Uncrustify tem muitas opções configuráveis. Você provavelmente precisará da GUI universal de recuperação (na resposta de Konstantin) também para configurá -la: http://universalindent.sourceforge.net/
Use comentários contendo /* *INDENT-OFF* */ e /* *INDENT-ON* */ para desativar o processamento de partes do arquivo de origem.
Consulte disable_processing_cmt de uncrustify.cfg :
# Specify the marker used in comments to disable processing of part of the
# file.
# The comment should be used alone in one line.
#
# Default: *INDENT-OFF*
disable_processing_cmt = " *INDENT-OFF* " # string
# Specify the marker used in comments to (re)enable processing in a file.
# The comment should be used alone in one line.
#
# Default: *INDENT-ON*
enable_processing_cmt = " *INDENT-ON* " # string Você pode integrar uncrustify com o IDE:
Consulte https://github.com/blockspacer/llvm_9_installer#how-to-use-with-sanitizers
Requer enable_llvm_tools=True , compile_with_llvm_tools=True e llvm_tools:build_type=Release :
-s llvm_tools:build_type=Release
-e flextool:enable_llvm_tools=True
-e flextool:compile_with_llvm_tools=True
-o llvm_tools:include_what_you_use=True
...enable_llvm_tools instala o CLANG 10 de Conancompile_with_llvm_tools define variáveis cmake necessárias para usar o CLANG 10 de Conan Execute conan install ou conan create com:
# OR create conan profile https://docs.conan.io/en/latest/reference/profiles.html
-s compiler=clang
-s compiler.version=10
-s compiler.libcxx=libc++ Nota: A alteração do compilador pode exigir reconstrução de todos os DEPS ( --build=missing ).
Exemplo em caso de compilação local:
export CC= $( find ~ /.conan/data/llvm_tools/master/conan/stable/package/ -path " *bin/clang " | head -n 1 )
export CXX= $( find ~ /.conan/data/llvm_tools/master/conan/stable/package/ -path " *bin/clang++ " | head -n 1 )
export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10
# NOTE: NO `--profile` argument cause we use `CXX` env. var
# NOTE: you may want to re-build `cling_conan` with clang 10
cmake -E time
conan install .
--install-folder local_build_clang_10
-s build_type=Debug
-s cling_conan:build_type=Release
-s llvm_tools:build_type=Release
--build missing
--build cascade
-s cling_conan:compiler=clang
-s cling_conan:compiler.version=10
-s cling_conan:compiler.libcxx=libstdc++11
-o llvm_tools:include_what_you_use=True
-s llvm_tools:compiler=clang
-s llvm_tools:compiler.version=10
-s llvm_tools:compiler.libcxx=libstdc++11
-e flextool:enable_tests=True
-e flextool:enable_llvm_tools=True
-e flextool:compile_with_llvm_tools=True
-e boost:enable_llvm_tools=True
-e boost:compile_with_llvm_tools=True
-s compiler=clang
-s compiler.version=10
-s compiler.libcxx=libc++
cmake -E time
conan source .
--source-folder local_build_clang_10
--install-folder local_build_clang_10
# remove old CMakeCache
(rm local_build_clang_10/CMakeCache.txt || true)
# see section about `conan editable mode`
conan build .
--build-folder local_build_clang_10
--source-folder local_build_clang_10
--install-folder local_build_clang_10Execute verificações:
# check that `libcpp` symbol exists
nm -an EXECUTABLE_PATH | grep libcpp
# list linked dynamic libs
ldd EXECUTABLE_PATH MCSS_ROOT_DIR_FOR_DOCS deve apontar para fontes m.css , como abaixo:
cd ~
git clone https://github.com/mosra/m.css.git
pip3 install jinja2 Pygments
sudo apt install
texlive-base
texlive-latex-extra
texlive-fonts-extra
texlive-fonts-recommended
sudo apt-get install doxygen
sudo apt install python3-pip
# /usr/bin/python must point to python3
/usr/bin/python --version
# NOTE: switch to python3 for doxygen or use -DPYTHON_EXECUTABLE=/usr/bin/python3
alias python= ' /usr/bin/python3 '
# You may need sudo here
pip3 install jinja2 Pygments
sudo apt install
texlive-base
texlive-latex-extra
texlive-fonts-extra
texlive-fonts-recommended Use CMake Build com '--Target doxydoc' e -DBUILD_DOXY_DOC=ON
cd ~ /flextool
# see section about `conan editable mode`
cd local_build_clang_10
# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)
# remove old build artifacts
rm -rf flextool
rm -rf bin
find . -iname ' *.o ' -exec rm {} ;
find . -iname ' *.a ' -exec rm {} ;
find . -iname ' *.dll ' -exec rm {} ;
find . -iname ' *.lib ' -exec rm {} ;
# remove old build docs
rm -rf doc-mcss
rm -rf docs
cmake -E make_directory " doc-mcss "
# NOTE: you can change python version like so: -DPYTHON_EXECUTABLE=/usr/bin/python3
cmake ..
-DCMAKE_VERBOSE_MAKEFILE=TRUE
-DMCSS_ROOT_DIR_FOR_DOCS= $HOME /m.css
-DPYTHON_EXECUTABLE=/usr/bin/python3
-DENABLE_TESTS=TRUE
-DBASE_NEED_GEN_BUILD_DATE=FALSE
-DENABLE_DOCTEST=ON
-DBUILD_DOXY_DOC=ON
-DBUILD_SHARED_LIBS=FALSE
-DCONAN_AUTO_INSTALL=OFF
-DCMAKE_BUILD_TYPE=Debug
-DDOXY_ROOT_DIR= $PWD /doc-mcss
-DDOXY_DOC_COMMON_IMG_PATH= $PWD /..
-DPROJECT_SOURCES_DIR_FOR_DOCS= $PWD /../src
cmake -E time cmake --build .
--target doxyDoc_notheme
cmake -E time cmake --build .
--target doxyDoc
# Use to find index.html
find $PWD -name * .htmlAbra doxydoc/html/index.html
Nota: Namespaces de documentos em docs/namespaces.dox
Nota: arquivos, diretórios e símbolos sem documentação não estão presentes na saída
Estilo de comentários usados:
/ **
* @brief Path utils
*
* Example usage:
*
* @code{.cpp}
* const ::fs::path workdir = storage::getThisBinaryDirectoryPath ();
* @endcode
** /Ver:
Para detalhes, consulte: https://afl-1.readthedocs.io/en/latest/index.html
NOTA: Prefere github.com/google/afl ou aflplus.plus para não atualizar AFL de lcamtuf.coredump.cx/afl
Fuzzing é uma técnica de teste de software de caixa preta.
A fuzzing consiste em encontrar bugs de implementação usando a injeção de dados malformada/semi-malformada de maneira automatizada.
Fuzzher tenta modificar a entrada para que possa atingir o máximo de linhas do código do programa.
Portanto, a fuzzing permite a descoberta de vulnerabilidades em caminhos de código difíceis de alcançar pelo uso normal.
Instale + compilar o código -fonte usando os seguintes comandos:
# optional
# sudo apt-get update
# optional
# sudo apt-get -y install autoconf automake bison build-essential
ca-certificates llvm-dev libtool libtool-bin
libglib2.0-dev make nasm wget
# Tested with clang 10 and gcc 7
sudo apt-get -y install clang-10 g++-7 gcc-7
export CXX=g++-7
export CC=gcc-7
export PATH=/usr/bin/: $PATH
$CC -v
# llvm-config binary that coresponds to the same clang you are using to compile
export LLVM_CONFIG=/usr/bin/llvm-config-10
$LLVM_CONFIG --cxxflags
cd ~
git clone -b v2.56b https://github.com/google/AFL.git --recursive
# NOTE: original AFL not updated since November 2017,
# so prefer `google/AFL.git` to `lcamtuf.coredump.cx/afl`
# wget http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz
# tar -xf afl-latest.tgz
# rm afl-latest.tgz
# cd afl*
cd AFL
make
# build llvm using the sample compiler as afl code uses
# see https://groups.google.com/forum/#!topic/afl-users/1WqZpGXvYY0
make
-C llvm_mode
LLVM_CONFIG= $LLVM_CONFIG
CC=clang-10
CXX=clang++-10
#
# optional
# cd qemu_mode
# ./build_qemu_support.sh
# cd ..
#
make
-C libdislocator
make
-C libtokencap
sudo make install
# OR add to PATH via export PATH=$PATH:...
# do not forget to reset CC and LLVM_CONFIG
unset CXX
unset CC
unset LLVM_CONFIG Nós compilamos o código usando o compilador AFL: -DCMAKE_C_COMPILER=afl-clang-fast , -DCMAKE_CXX_COMPILER=afl-clang-fast++ -DCMAKE_LINKER=afl-clang-fast .
Para verificar se o binário usa o compilador AFL: nm BINARY_PATH | grep afl
Para criar aplicativos com alguns desinfetantes e informações de depuração ativadas: ( -DENABLE_ASAN=ON etc.):
NOTA: Há algumas coisas a considerar ao usar o desinfetante de endereço. Mesmo que a ASAN encontre uma violação de acesso à memória, ele não trava automaticamente o aplicativo. Isso é um problema ao usar ferramentas automatizadas de fuzzing, porque elas geralmente tentam detectar o Segfaults, verificando o código de retorno. No entanto, podemos forçar asan a travar o software quando um erro ocorre com a variável de ambiente asan_options antes de fuzzing: export ASAN_OPTIONS='abort_on_error=1'
Nota: Desative as funções de alocação de memória personalizadas. Isso pode ocultar erros de acesso à memória e impedir a detecção de erros de acesso à memória.
# see https://afl-1.readthedocs.io/en/latest/instrumenting.html
# Setting AFL_HARDEN automatically adds code hardening options
# when invoking the downstream compiler.
# This includes -D_FORTIFY_SOURCE=2 and -fstack-protector-all.
# NOTE: _FORTIFY_SOURCE not compatible with ASAN
# export AFL_HARDEN=1
# see https://aflplus.plus/docs/env_variables/
export AFL_EXIT_WHEN_DONE=1
# By default, the wrapper appends -O3 to optimize builds.
export AFL_DONT_OPTIMIZE=1
# or AFL_USE_MSAN, etc.
# READ https://aflplus.plus/docs/notes_for_asan/
NOTE: if you run several slaves only one should run the
# target compiled with ASAN (and UBSAN, CFISAN),
# the others should run the target with no sanitizers compiled in.
export AFL_USE_UBSAN=1
export AFL_USE_ASAN=1
# AFL_PRELOAD causes AFL to set LD_PRELOAD for the target binary
# without disrupting the afl-fuzz process itself.
# This is useful, among other things, for bootstrapping libdislocator.so.
# see __AFL_LOOP
# export AFL_PERSISTENT=1
# make sure you compile app with `-fsanitize=address` or `-fsanitize=memory` etc. Nota: Use AFL_DONT_OPTIMIZE=1 ; Leia: http://moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html
Para detalhes, consulte: Usando asan com AFL
Antes de confundir o programa, podemos exigir que a troca para o usuário root para organizar o core_pattern. Faça login como root e digite o seguinte comando:
# see https://afl-1.readthedocs.io/en/latest/tips.html#check-os-configuration
sudo su
# disable core dumps and CPU frequency scaling on your system (AFL will warn you if you should do this)
echo core > /proc/sys/kernel/core_pattern
# afl-fuzz will usually complain that you should change your `CPUFREQ` settings to performance because the automatic frequency scaling by the Linux kernel doesn't work well with afl.
echo performance | tee /sys/devices/system/cpu/cpu * /cpufreq/scaling_governor
exitNota: Não execute o Fuzzher com acesso root
Nota: Obtenha um ambiente sólido para o Fuzzher; Nunca execute o Fuzzher em hipervisores baixos configurados.
afl-fuzz é usado para executar a AFL. A sintaxe real é a seguinte:
# see https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries
# -i is a directory of files to use as fuzz input "seeds"
# -o is a directory to write the results (including inputs that provoke crashes or hangs)
# -m is the memory allowed to use. Example: -m500
# You can use -m none to disable memory limit
# -t is the maximum time that a run is allowed to take before being declared a "hang"
# Timeout of 10 seconds: -t 10000
# @@ is fuzzer input file name
# if you skip @@ it will pass the fuzzed file on the standard input
AFL_PERSISTENT=1 afl-fuzz -i [TESTCASE DIR] -o [RESULT_DIR] [TARGET_BINARY] [BINARY_PARAMS] @@
# Example 1: runs `tar` with arguments `xfJ @@ -C fuzz-garbage/ --force-local`
# where @@ is fuzzer input file name
./afl-1.56b/afl-fuzz -i fuzz-input/ -o fuzz-state/ -t 10000 ~ /tar-1.28/src/tar xfJ @@ -C fuzz-garbage/ --force-local
# Example 2: server is dual core, so we can run one AFL instance per core
AFL_PERSISTENT=1 afl-fuzz -i inputs -o multi_sync -M master ./fuzz_capstone
# In another terminal
AFL_PERSISTENT=1 afl-fuzz -i inputs -o multi_sync -S slave1 ./fuzz_capstonePara entender a tela de status AFL, leia: https://fl-1.readthedocs.io/en/latest/user_guide.html#status-screen
Nota: Se total paths permanecer em 1, você provavelmente configurou algo errado.
NOTA: Prefere -m none . Usamos o endereço de endereço; Isso mapeia muitas páginas para a memória de sombra, então precisamos remover o limite de memória para funcioná -lo.
NOTA: Com -m none , seu software difamado pode realmente tentar realmente alocar e usar muita memória devido às suas amostras difundidas. Isso pode levar a falhas aleatórias em seu sistema. Você não deve fazer nenhum trabalho importante enquanto faz isso.
NOTA: Você pode experimentar ASAN_OPTIONS=hard_rss_limit_mb=2000 para evitar -m none . Veja: https://countuponsecurity.com/category/fuzzing/
Você pode escrever um binário personalizado que será executado usando afl-fuzz . Pode envolver a função que você deseja testar assim:
// harness is simply a C program that makes use of certain methods from
// a library, allowing you to indirectly fuzz it
# include < cstdio >
# include < cstdlib >
# include < string >
# include < iostream >
# include < ifstream >
int main ( int argc, char *argv[]) {
{
// init resources here
if (argc > 1 ) {
std::ifstream fin;
fin. open (argv[ 1 ]);
parse (fin); // custom logic
} else {
// / note requires AFL_PERSISTENT=1
// __AFL_LOOP is the way that we have to tell AFL
// that we want persistent mode.
// Each fuzzing iteration,
// instead of to fork and re-execute the target with a different input,
// is just an execution of this loop.
// Force AFL to run 1000 times,
// with 1000 different inputs fed to the library.
// After that, the process is restarted by AFL.
// This ensures we regularly replace the process to avoid memory leaks.
// see https://toastedcornflakes.github.io/articles/fuzzing_capstone_with_afl.html
while ( __AFL_LOOP ( 1000 )) {
parse (std::cin); // custom logic
}
}
// free resources here
return 0 ;
} NOTA: __AFL_LOOP () permite que a AFL execute a fuzzing do binário em processo por meio de alguma assistência de memória, em vez de iniciar um novo processo para cada novo teste que queremos testar. Requer AFL_PERSISTENT=1 .
Por padrão, a AFL forks um processo toda vez que testa uma entrada diferente. Podemos controlar a AFL para executar vários casos de fuzz em uma única instância do programa, em vez de reverter o estado do programa para cada amostra de teste. Isso reduzirá o tempo gasto no espaço do kernel e melhorará a velocidade de fuzzing. Isso é chamado de modo AFL_PERSISTENT. Podemos fazer isso incluindo a macro __AFL_LOOP (1000) dentro do nosso chicote de teste.
Nota: Você pode estar interessado em __AFL_init; Consulte os detalhes: https://robertheaton.com/2019/07/08/how-to-write-an-afl-wrapper-for-any-language/
Deixe o Fuzzher funcionar por algumas horas ou dias, pois gera caminhos máximos de execução de código com base nos casos de teste fornecidos.
Pare de fuzir a emissão de ctrl+c' observing os caminhos totais and as traveiras da UNIQ in the section Resultados gerais da tela de estatísticas AFL.
Crie dicionário que pegue todas as constantes e cordas encontradas no programa binário e as adiciona ao dicionário. Consulte o código do script: http: //moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html
#! /bin/bash
# see http://moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html
objdump -d " ${1} " | grep -Eo ' $0x[0-9a-f]+ ' | cut -c 2- | sort -u | while read const ; do echo $const | python -c ' import sys, struct; sys.stdout.write("".join(struct.pack("<I" if len(l) <= 11 else "<Q", int(l,0)) for l in sys.stdin.readlines())) ' > testcases/ $const ; done
i=0 ; strings " ${1} " | while read line ; do echo -n " $line " > testcases/string_ ${i} ; i=$[ $i + 1 ] ; doneVocê precisa criar um dicionário em um dos dois formatos discutidos nos dicionários/readme.dicionários e, em seguida, aponte o Fuzzher para ele através da opção -x na linha de comando. Leia: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries e https://github.com/mirrorer/fl/blob/master/dictionaries/readme.dictionárias
Você também pode usar libtokencap para criar um dicionário; Veja: https://github.com/mirrorer/afl/blob/master/libtokencap/readme.tokencap
Podemos encontrar os casos de teste que causam a falha na pasta de results que criamos. Na navegação nos results da pasta, observamos que poucas pastas são geradas.
Nota: mantenha os arquivos de dados de entrada pequenos; abaixo de 1 kb é ideal.
Use afl-cmin para minimizar o número de arquivos de dados de entrada.
Use afl-tmin para minimizar cada arquivo de dados de entrada (remove qualquer bytes que não afetem os caminhos de código tomados).
Use afl-ptmin para executar afl-tmin em paralelo. Para detalhes, consulte: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows--fuzz-job-from-start-to-finish/
Para reproduzir o acidente encontrado, você pode usar crashwalk (é o plug-in GDB), consulte: https://ritcsec.wordpress.com/2018/05/10/vulnerability-discovery-by-fuzzing/
apt-get install gdb golang
mkdir src
cd src
git clone https://github.com/jfoote/exploitable.git
cd && mkdir go
export GOPATH= ~ /go
# crashwalk installed in $GOPATH/bin/
go get -u github.com/bnagy/crashwalk/cmd/...
# USAGE
~ /go/bin/cwtriage -root syncdir/fuzzer1/crashes/ -match id -- ~ /parse @@Quando você não pode reproduzir uma falha encontrada pelo AFL-FUZZ, a causa mais provável é que você não esteja definindo o mesmo limite de memória usado pela ferramenta. Leia: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries
Nota: Você pode usar afl-cov para quantificar o quão bem está exercitando os caminhos de código disponíveis no binário. Para detalhes, consulte: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows--fuzz-job-from-start-to-finish/
Nota: Colocando o diretório de trabalho da AFL em um disco RAM, você pode obter uma velocidade adicional e evitar desgastar os discos ao mesmo tempo. Para detalhes, consulte: https://bananamafia.dev/post/gb-fuzz/
# Fuzzing involves billions of reads and writes to the filesystem (!!!)
# Use RAMdisks for input since, we don't want to destroy harddrives
# Make a 1GB ramdisk file from which AFL can read input
sudo mkdir -p /mnt/inputfiles
sudo chown -R $USER : $( id -gn $USER ) /mnt/inputfiles
sudo mount -t tmpfs -o size=1024M tmpfs /mnt/inputfiles/ NOTA: -fvisibility-inlines-hidden PODE AS PELA INSTRUMENTAÇÃO AFL
AFL fornece um script de exploração de colisão em experimental/crash_triage/triage_crashes.sh
Quando executado, o script de triagem percorre cada arquivo de falha no diretório /out/crashes e imprime os dados de falha resultantes para a tela.
triage_crashes Uso: ./triage_crashes.sh ~/targets/out/ ~/targets/target-app/target-app_binary para obter detalhes, consulte: https://research.aurainfosec.io/hunting-for-bugs-101/
Nota: Instrumento com AFL apenas as bibliotecas que você realmente deseja no teste de estresse agora, uma de cada vez. Deixe o programa usar bibliotecas não instrumentadas em todo o sistema para qualquer funcionalidade que você realmente não deseja confundir.
Nota: você pode ativar crash exploration mode via -C ; Veja: https://lcamtuf.blogspot.com/2014/11/afl-fuzz-crash-exploration-mode.html
NOTA: A AFL detecta falhas verificando o primeiro processo gerado devido a um sinal (Sigsegv, Sigabrt, etc). Os programas que instalam manipuladores personalizados para esses sinais podem precisar que o código relevante seja comentado.
Para detalhes, consulte:
O Libfuzzer faz parte do projeto de infraestrutura do compilador LLVM e vem embutido com o compilador CLANG.
Em seguida, a libfuzzer pode ser vinculada ao motorista desejado, passando -fsanitize=fuzzer durante o estágio de ligação.
Nota: -fsanitize=fuzzer no símbolo principal do libfuzer ().
NOTA: Na maioria dos casos, você pode combinar o libfuzer com o endereço de endereço (ASAN), o AndefinedBehaviorsanitizer (UBSAN) ou ambos. Você também pode construir com o MemorySanitizer (MSAN), mas o suporte é experimental: -fsanitize=undefined,address,fuzzer .
Executável chama repetidamente a seguinte função:
extern " C " int LLVMFuzzerTestOneInput ( const uint8_t *Data, size_t Size ) {
// DoStuffWithYourAPI(Data, Size);
return 0 ;
} Use -fsanitize=address,fuzzer . Observe que você pode alterar o Sinitizador (endereço, memória, thread, etc.).
Nota: Se você suspeitar que vazamentos de memória em seu destino, execute o libfuzzer com -runs=N ou -max_total_time=N . Se o seu alvo tiver vazamentos enormes, você acabará por ficar sem RAM. Para proteger sua máquina da morte de OOM, você pode usar: ASAN_OPTIONS=hard_rss_limit_mb=2000 (com o endereçosanitizador).
Libfuzzer requer corpus de semente. Para detalhes, consulte: https://github.com/google/fuzzing/blob/master/tutorial/libfuzzertutorial.md
Para detalhes, consulte:
Clang suporta anotações de segurança de threads (guarded_by)
-Wthread-safety-analysisbase/thread_annotations.h https://github.com/chromium/chromium/blob/master/base/thread_annotações.h para obter detalhes, consulte:CLANG FAS APROPUTO PRIMEIRA CLASSE para desinfetantes. Veja detalhes sobre Msan, Asan, Tsan, etc. nos documentos.
CLANG pode ser construído com perfil vitalício:
-Wlifetime para obter detalhes, consulte:Todos os componentes de código aberto são usados sob suas licenças de código aberto associadas.
Utilizou componentes de código aberto:
Consulte os arquivos de licença
a licença do MIT
Consulte a licença para o conteúdo completo das licenças.
Esse projeto de código aberto com base no projeto do Google Chromium.
Este não é um produto oficial do Google.
Porções Copyright (c) Google Inc.
Consulte os arquivos de licença.
