flextool
1.0.0
Una solución de código completamente abierto y potente para la modificación y generación del código fuente C ++. Reduzca la cantidad de código de horarios en sus proyectos C ++.
Página principal del proyecto: https://blockspacer.github.io/flex_docs/
Probado en Ubuntu 20.04.2 Lts.
Puede funcionar en otras plataformas con modificaciones menores.
Para poder agregar la lista de remotos de dependencia, escriba el siguiente comando:
cmake -E time conan config install conan/remotes/
# OR:
# cmake -E time conan config install conan/remotes_disabled_ssl/ Guía de instalación
Paquetes de Conan
Nota: Agardar con LLVM Build puede llevar un par de horas.
El comando a continuación usa --profile clang12_compiler12_compiler .
Ejemplo de perfil de conan ~/.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/stableCrear 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 de la creación del archivo de perfil de Conan, consulte: https://docs.conan.io/en/latest/using_packages/using_profiles.html.
Utilizamos el script .cmake para descargar e instalar paquetes de 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 Si desea instalar FLextool y sus complementos en el comando único, cambie las opciones proporcionadas a tools/buildConanThirdparty.cmake .
Nota: tools/buildConanThirdparty.cmake realizará una reconstrucción completa; Puede llevar un par de horas.
El comando a continuación usa --profile clang12_compiler12_compiler . Antes de la creación del archivo de perfil de Conan, consulte: https://docs.conan.io/en/latest/using_packages/using_profiles.html.
Utilizamos el script buildConanThirdparty.cmake para descargar e instalar paquetes de Conan.
NOTA: SET -DENABLE_CLING=FALSE Si ya instaló el cierre usando tools/buildConanThirdparty.cmake arriba.
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 el comando a continuación para reconstruir FlexxTool (los complementos deben instalarse por separado).
El comando a continuación usa --profile clang12_compiler12_compiler . Antes de la creación del archivo de perfil de 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.jsonDeshabilite la generación de la base de datos de compilación cuando use FLextool.
Si está utilizando CMake, establezca CMAKE_EXPORT_COMPILE_COMMANDS en FALSE .
Si compile_commands.json existe en la carpeta de compilación (o en la carpeta matriz), FlexxTool puede fallar.
Este proyecto es posible debido al autoprogrammer de FlexFerrum.
Artículos sobre autoprogrammer de FlexFerrum en los medios:
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 Con los paquetes editables, puede decirle a Conan dónde encontrar los encabezados y los artefactos listos para el consumo en su directorio de trabajo local. No hay necesidad de ejecutar conan create o conan export-pkg .
Para más detalles, 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_buildEstablecer el paquete en modo editable:
conan editable add local_build/package_dir
flextool/master@conan/stable Tenga en cuenta que conanfile.py se modifica para detectar compilaciones locales a través de self.in_local_cache .
Después de cambiar la fuente en la carpeta local_build (ejecute los comandos en la carpeta del paquete de origen):
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
Cree su proyecto de prueba.
Para revertir el modo editable, simplemente elimine el enlace usando:
conan editable remove
flextool/master@conan/stable Permite construir múltiples proyectos a la vez; Simplemente crea CMakeLists.txt con add_subdirectory apuntando a cada carpeta de paquete.
Nota: ¡Puede abrir el espacio de trabajo en IDE como un proyecto basado en CMake de costumbre (Cambie el directorio de compilación a la ruta de WorkSpaceProject)!
Para más detalles, consulte: https://docs.conan.io/en/latest/developing_packages/workspaces.html
Por ejemplo, queremos construir FlexxTool y FlexLib al mismo tiempo (FlexxTool requiere 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 Construir en la carpeta creada 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_testsWorkspace permite realizar cambios rápidos en los archivos de origen existentes.
Usamos self.in_local_cache para detectar el modo editable de 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 )Asegúrese de que todos los objetivos tengan nombres globalmente únicos.
Por ejemplo: no puede tener un objetivo en cada proyecto con el mismo nombre como "prueba". Puede resolver ese problema agregando prefijo específico del proyecto al nombre de cada objetivo como "$ {root_project_name} -test_main_gtest".
Debido a que CMAKE_BINARY_DIR apuntará a la carpeta creada por conan workspace install , asegúrese de preferir CMAKE_CURRENT_BINARY_DIR a CMAKE_BINARY_DIR etc.
Antes de la instalación: los complementos requieren FLexTool pre-construido (en el mismo espacio de trabajo). Debe construir espacio de trabajo sin complementos; Solo entonces podrás reconstruirlo con complementos.
Agregue complementos al archivo 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 en 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 Agregar opciones de complementos a 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=TrueBuild and Test Workspace:
# 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 Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True .
Instale cppcheck a través de 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 (ejecuta Cmake con -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.htmlAbra 'index.html' para ver los resultados.
Aplicación de escritorio que proporciona un contexto único para administrar y ejecutar múltiples scripts.
Simplifica la configuración del entorno de desarrollo local; Esto evita abrir muchas terminales de conchas.
Puede agregar comandos personalizados en package.json o 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 --versionConstruya su proyecto a través de NPM:
npm installsudo npm install -g @vue/cli
sudo vue ui --dev --port 8061 Abra http://localhost:8061/ .
Directorio de proyectos de importación.
Seleccione Tasks , como construir/probar ...
Las tareas se pueden cambiar en package.json .
Nota: usamos package.json solo para tareas. Conan está controlado por un archivo llamado Conanfile.txt.
Enlaces útiles:
Usamos .gdbinit Agregar 'Add-Auto-Load-Safe-Path'.
Para obtener más detalles sobre .gdbinit , lea: https://metricpanda.com/tips-for-productive-devugging-with-gdb
Para obtener más detalles sobre gdb , lea: http://www.yolinux.com/tutorials/gdb-commands.html
La sesión de depuración de GDB se puede automatizar de la misma manera:
# 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} Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True .
Para más detalles, ver:
Instalar Valgrind:
sudo apt install valgrind # Ubuntu, Debian, etc.
# OR
sudo yum install valgrind # RHEL, CentOS, Fedora, etc. Nota: Asegúrese de establecer use_alloc_shim=False y enable_valgrind=True (ver más abajo).
Ejecute Valgrind a través de 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 fugas, puede perseguir definitely lost en el archivo de registro.
Nota: Puede agregar supresiones de Valgrind en cmake/valgrind.cfg .
Nota: Compile el programa con una bandera de depuración para ejecutarse bajo Valgrind.
NOTA: Use valgrind --tool=helgrind para detectar posibles puntos muertos y carreras de datos.
Nota: use valgrind --tool=massif --massif-out-file=massif_file --stacks=true para medir el tamaño del montón. Ver también: https://kde.org/applications/development/org.kde.massif-visualizer
Para más detalles, consulte: https://stackoverflow.com/a/44989219
TODO: Intente construir con Valgrind y Clang 10 https://stackoverflow.com/questions/405099986/valgrind-reporting-shisched free-delete-delete
TODO: Valgrind puede no admitir la base de cromo, FixMe. Y eliminar gtest_no_suite
Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True
Instalar clang-tidy:
sudo apt-get install clang-tidy # Ubuntu, Debian, etc.
# OR
sudo yum install clang-tidy # RHEL, CentOS, Fedora, etc. Uso (ejecuta cmake con -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 Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True
Para obtener más detalles, consulte: https://chromium.googlesource.com/chromium/src.git/+/master/docs/clang_static_analyzer.md y https://clang-analyzer.llvm.org/scan-build.html
El programa CCC-Analyzer actúa como un compilador falso, reenviando sus argumentos de línea de comando al compilador para realizar una compilación regular y un estrecho para realizar un análisis estático.
Ejecutar Configurar típicamente genera mapeos que tienen rutas cableadas al compilador, y ejecutando configurar a través de Scan-build, esa ruta está configurada en CCC-Analyzer.
# 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 el archivo scanbuildout/...../index.html
Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True
Para más detalles, consulte: https://github.com/myint/cppclean
Instalación:
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 (ejecuta Cmake con -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: CPPClean requiere que la codificación de archivos sea: UTF-8 without BOM (ASCII)
Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True
Incluir: lo que te gusta (IWYU) es un proyecto destinado a optimizar las incluye.
Calculará los encabezados requeridos y agregará / eliminará las incluido según corresponda.
Para más detalles, consulte: https://include-what-you-use.org/
Uso (ejecuta cmake con -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 en archivos fuente de C ++.
Nota: Lea sobre Iwyu Pragmas: https://github.com/include-what-you-use/include-whatyou-use/blob/master/docs/iwyupragmas.md
Nota: No use "bits/" o "/detalles/*" incluye, agrégalos al archivo de asignación (.Imp)
Para más detalles, ver:
Usar -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 obtener más detalles, consulte: https://www.virag.si/2015/07/use-ccache-with-cmake-for-faster-compilación/
Para aprovechar al máximo ccache, coloque algo como esto en: ~/.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: Se requiere base_dir para que CCACHE comparta las compilaciones en caché del mismo archivo en diferentes repositorios / rutas; Solo hará esto para rutas bajo base_dir . Por lo tanto, esta opción es necesaria para el uso efectivo de CCACHE con GIT Worktrees (que se describe a continuación).
No debe establecer base_dir en "/", o en cualquier lugar que contenga encabezados del sistema (de acuerdo con los documentos CCACHE).
Instalación:
sudo apt-get install ccache
# On OS X use homebrew:
# brew install ccache
ccache --version Usar -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 más detalles, consulte: https://cristianadam.eu/20170709/speeding-upcmake/
NOTA: El oro no está enhebrado de forma predeterminada, configure con "--enable-Threads"
Nota: LLD enhebrado de forma predeterminada puede ser más rápido que el oro
Asegúrese de usar la construcción Debug con -e flextool:enable_llvm_tools=True
Para más detalles, consulte: https://oclint-docs.readthedocs.io/en/stable/devel/codingstandards.html
Instalación:
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 (ejecuta CMake con -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.htmlAbrir informe.html
Ver Tutorial de Oclint: http://docs.oclint.org/en/stable/intro/tutorial.html
Consulte la lista de reglas de oclint en: https://oclint-docs.readthedocs.io/en/stable/rules/
Nota: Puede suprimir las advertencias de oclint http://docs.oclint.org/en/stable/howto/supess.html#oclint-comment
Para más detalles, consulte: https://clang.llvm.org/docs/clangformat.html
Uso (ejecuta Cmake con -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 el archivo .clang-format . Para más detalles, consulte: https://clang.llvm.org/docs/clangformatstyleoptions.html
Nota: Usamos DisableFormat , por lo que Clang-Format cambiará solo incluir el orden basado en SortIncludes .
Desafortunadamente, clang-format no es lo suficientemente configurable, por lo que solo se puede usar para clasificar. Ver: https://stackoverflow.com/a/32191189
Utilizamos un bacause de clang-formato y Astyle no admiten muchas opciones.
Para más detalles, consulte: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html
Instalación:
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 (ejecuta cmake con -DENABLE_UNCRUSTIFY=ON )::
# creates local build in separate folder and runs cmake targets
cmake -DUNCRUSTIFY= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake Utilizamos un archivo uncrustify.cfg . Para más detalles, consulte: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html
Para obtener una lista de todas las opciones disponibles.
uncrustify --show-configUnrustify tiene muchas opciones configurables. Probablemente también necesitará la GUI de la sangría universal (en la respuesta de Konstantin) para configurarla: http://universalindent.sourceforge.net/
Use comentarios que contengan /* *INDENT-OFF* */ y /* *INDENT-ON* */ para deshabilitar el procesamiento de partes del archivo de origen.
Ver disable_processing_cmt desde 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 Puede integrar uncrustify con IDE:
Ver https://github.com/blockspacer/llvm_9_installer#how-to-use-with-sanitizers
Requiere enable_llvm_tools=True , compile_with_llvm_tools=True , y 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 installs clang 10 de Conancompile_with_llvm_tools Establece las variables Cmake requeridas para usar Clang 10 de Conan Ejecute conan install o conan create con:
# 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: El cambio de compilador puede requerir la reconstrucción de todos los Deps ( --build=missing ).
Ejemplo en caso de construcción 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_10Realizar cheques:
# check that `libcpp` symbol exists
nm -an EXECUTABLE_PATH | grep libcpp
# list linked dynamic libs
ldd EXECUTABLE_PATH MCSS_ROOT_DIR_FOR_DOCS debe apuntar a fuentes m.css como a continuación:
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 la construcción de cmake con '-Atget doxydoc' y -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: espacios de nombres de documentos en documentos/espacios de nombres.dox
Nota: los archivos, directorios y símbolos sin documentación no están presentes en la salida en absoluto
Estilo de comentarios usados:
/ **
* @brief Path utils
*
* Example usage:
*
* @code{.cpp}
* const ::fs::path workdir = storage::getThisBinaryDirectoryPath ();
* @endcode
** /Ver:
Para más detalles, consulte: https://afl-1.readthedocs.io/en/latest/index.html
Nota: Prefiere github.com/google/afl o aflplus.plus a AFL no actualizado desde lcamtuf.coredump.cx/afl
Fuzzing es una técnica de prueba de software de caja negra.
La fuzzing consiste en encontrar errores de implementación utilizando inyección de datos malformada/semi-malformada de manera automatizada.
Fuzzer intenta modificar la entrada para que pueda alcanzar la mayor cantidad de líneas del código del programa como sea posible.
Por lo tanto, la fuzzing permite el descubrimiento de vulnerabilidades que se encuentran en las rutas de código que son difíciles de alcanzar por el uso normal.
Instalar + compilar el código fuente utilizando los siguientes 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 Compilamos el código usando el compilador AFL: -DCMAKE_C_COMPILER=afl-clang-fast , -DCMAKE_CXX_COMPILER=afl-clang-fast++ y -DCMAKE_LINKER=afl-clang-fast .
Para verificar si binario usa el compilador AFL: nm BINARY_PATH | grep afl
Para construir la aplicación con algunos desinfectantes y la información de depuración habilitada: ( -DENABLE_ASAN=ON , etc.):
Nota: Hay algunas cosas a considerar al usar el desinfectante de direcciones. Incluso si Asan encuentra una violación de acceso a la memoria, no bloquea automáticamente la aplicación. Este es un problema cuando se usan herramientas de fuzzing automatizadas porque generalmente intentan detectar SEGFaults revisando el código de retorno. Sin embargo, podemos obligar a ASAN a bloquear el software cuando ocurre un error con la variable de entorno ASAN_OPTIONS antes de la fuzzing: export ASAN_OPTIONS='abort_on_error=1'
Nota: Desactive las funciones de asignación de memoria personalizada. Esto puede ocultar errores de acceso a la memoria y evitar la detección de errores de acceso a la memoria.
# 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 ; Lea: http://moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html
Para más detalles, consulte: Uso de Asan con AFL
Antes de borrar el programa, es posible que requiera cambiar al usuario root para organizar el Core_Pattern. Iniciar sesión como root y escriba el siguiente 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: No ejecute el fuzzer con acceso a la raíz
Nota: Obtenga un entorno sólido para el fuzzer; Nunca ejecute el fuzzer en hipervisores con configuración baja.
afl-fuzz se usa para ejecutar AFL. La sintaxis real es la siguiente:
# 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 comprender la pantalla de estado de AFL, lea: https://afl-1.readthedocs.io/en/latest/user_guide.html#status-screen
Nota: Si total paths permanecen en 1, probablemente haya configurado algo mal.
NOTA: Prefiere -m none . Utilizamos direcciones de avesanitizador; Esto mapea muchas páginas para la memoria de la sombra, por lo que tenemos que eliminar el límite de memoria para que se ejecute.
Nota: con -m none , su software confuso puede intentar realmente asignar y usar mucha memoria debido a sus muestras confusadas. Esto puede conducir a bloqueos aleatorios en su sistema. No debes hacer ningún trabajo importante mientras lo haces.
Nota: puede probar ASAN_OPTIONS=hard_rss_limit_mb=2000 para evitar -m none . Ver: https://countuponsecurity.com/category/fuzzing/
Puede escribir binario personalizado que se ejecutará usando afl-fuzz . Puede envolver la función que desea probar así:
// 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 a AFL realizar la fuzzación del binario en proceso a través de alguna magia de memoria, en lugar de iniciar un nuevo proceso para cada nueva prueba que queremos probar. Requiere AFL_PERSISTENT=1 .
Por defecto, AFL bifurca un proceso cada vez que prueba una entrada diferente. Podemos controlar AFL para ejecutar múltiples casos de fuzz en una sola instancia del programa, en lugar de volver al estado del programa para cada muestra de prueba. Esto reducirá el tiempo dedicado al espacio del núcleo y mejorará la velocidad confusa. Esto se llama modo AFL_PERSISTENT. Podemos hacerlo incluyendo la macro __afl_loop (1000) dentro de nuestro arnés de prueba.
Nota: puede estar interesado en __afl_init; Ver para obtener más detalles: https://ercertheaton.com/2019/07/08/how-to-write-an-afl-wrapper-for-any-language/
Deje que el fuzzer se ejecute durante unas pocas horas o días, ya que genera rutas de ejecución de código máximo en función de los casos de prueba proporcionados.
Deje de fuzzing emitir ctrl+c' observing rutas totales and bloqueos UNIQ in the section Resultados generales' de la pantalla de estadísticas de AFL.
Cree un diccionario que tome todas las constantes y cuerdas que se encuentran en el binario del programa y los agrega al diccionario. Consulte el código de 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 ] ; doneDebe crear un diccionario en uno de los dos formatos discutidos en diccionarios/readMe.Diccionarios y luego señalarle el fuzzer a través de la opción -x en la línea de comandos. Lea: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries y https://github.com/mirrorer/afl/blob/diccionaries/readme.dictionaries
También puede usar libtokencap para crear un diccionario; Ver: https://github.com/mirrorer/afl/blob/master/libtokencap/readme.tokencap
Podemos encontrar los casos de prueba que causan el bloqueo en la carpeta results que hemos creado. Al navegar a results de la carpeta, observamos que se generan pocas carpetas.
Nota: Mantenga los archivos de datos de entrada pequeños; menos de 1 kb es ideal.
Use afl-cmin para minimizar el número de archivos de datos de entrada.
Use afl-tmin para minimizar cada archivo de datos de entrada (elimine los bytes que no afecten las rutas de código tomadas).
Use afl-ptmin para ejecutar afl-tmin en paralelo. Para más detalles, consulte: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/
Para reproducir un bloqueo encontrado, puede usar crashwalk (es un complemento 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 @@Cuando no puede reproducir un bloqueo encontrado por AFL-Fuzz, la causa más probable es que no esté estableciendo el mismo límite de memoria que utiliza la herramienta. Lea: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries
Nota: Puede usar afl-cov para cuantificar qué tan bien está ejerciendo las rutas de código disponibles en el binario. Para más detalles, consulte: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/
Nota: Poner el directorio de trabajo de la AFL en un disco RAM, puede ganar una velocidad adicional y evitar desgastar los discos al mismo tiempo. Para más detalles, 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 -fvisibility puede romper la instrumentación AFL
AFL proporciona un script de exploración de choques en experimental/crash_triage/triage_crashes.sh
Cuando se ejecuta, el script de triaje en bicicleta a través de cada archivo de bloqueo en el directorio /out/crashes e imprimirá los datos de bloqueo resultantes en la pantalla.
uso triage_crashes : ./triage_crashes.sh ~/targets/out/ ~/targets/target-app/target-app_binary para más detalles, consulte: https://research.aurainfosec.io/hunting-for-bugs-101/
Nota: Instrumento con AFL solo las bibliotecas que realmente desea probar en este momento, una a la vez. Deje que el programa use bibliotecas no instrumentadas en todo el sistema para cualquier funcionalidad que en realidad no desee borrar.
Nota: puede habilitar crash exploration mode a través de -C ; Ver: https://lcamtuf.blogspot.com/2014/11/afl-fuzz-crash-exploration-mode.html
Nota: AFL detecta fallas al verificar el primer proceso generado morir debido a una señal (SIGSEGV, SIGABRT, etc.). Los programas que instalan controladores personalizados para estas señales pueden necesitar que comenten el código relevante.
Para más detalles, ver:
Libfuzzer es parte del proyecto de infraestructura del compilador LLVM y viene incorporado con el compilador de clang.
Entonces Libfuzzer se puede vincular al controlador deseado pasando en -fsanitize=fuzzer durante la etapa de enlace.
Nota: -fsanitize=fuzzer Enlace en el símbolo Main () de Libfuzzer.
NOTA: En la mayoría de los casos, es posible que desee combinar libfuzzer con DirectSanitizer (ASAN), Undefined Behaviorsanitizer (UBSAN), o ambos. También puede construir con MemorySanitizer (MSAN), pero el soporte es experimental: -fsanitize=undefined,address,fuzzer .
Ejecutable llama repetidamente la siguiente función:
extern " C " int LLVMFuzzerTestOneInput ( const uint8_t *Data, size_t Size ) {
// DoStuffWithYourAPI(Data, Size);
return 0 ;
} Use -fsanitize=address,fuzzer . Tenga en cuenta que puede cambiar el desinfectante (dirección, memoria, hilo, etc.).
Nota: Si sospecha que se filtra en su objetivo, debe ejecutar libfuzzer con -runs=N o -max_total_time=N . Si su objetivo tiene fugas masivas, eventualmente se quedará sin RAM. Para proteger su máquina de la muerte de OOM, puede usar: ASAN_OPTIONS=hard_rss_limit_mb=2000 (con directssanitizer).
Libfuzzer requiere un corpus de semillas. Para más detalles, consulte: https://github.com/google/fuzzing/blob/master/tutorial/libfuzzertutorial.md
Para más detalles, ver:
Clang admite anotaciones de seguridad del hilo (Guarded_by)
-Wthread-safety-analysisbase/thread_annotations.h https://github.com/chromium/chromium/blob/master/base/thread_annotations.h para más detalles, consulte:CLANG FAS Soporte de primera clase para desinfectantes. Vea los detalles sobre Msan, Asan, Tsan, etc. en Docs.
Clang se puede construir con perfil de por vida:
-Wlifetime para más detalles, consulte:Todos los componentes de código abierto se utilizan bajo sus licencias de código abierto asociadas.
Se utilizaron componentes de código abierto:
Ver archivos de licencia
la licencia del MIT
Vea la licencia para el contenido completo de las licencias.
Ese proyecto de código abierto basado en el proyecto Google Chromium.
Este no es un producto oficial de Google.
Porciones Copyright (c) Google Inc.
Ver archivos de licencia.
