1cmake_minimum_required(VERSION 3.12) 2 3# Defer enabling C and CXX languages. 4project(BoringSSL NONE) 5 6# Don't install BoringSSL to system directories by default; it has no stable 7# ABI. Instead, default to an "install" directory under the source. 8if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) 9 set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install CACHE PATH "" FORCE) 10endif() 11 12if(WIN32) 13 # On Windows, prefer cl over gcc if both are available. By default most of 14 # the CMake generators prefer gcc, even on Windows. 15 set(CMAKE_GENERATOR_CC cl) 16endif() 17 18include(cmake/go.cmake) 19include(cmake/paths.cmake) 20include(gen/sources.cmake) 21 22enable_language(C) 23enable_language(CXX) 24 25include(GNUInstallDirs) 26 27set(INSTALL_ENABLED 1) 28 29if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT CMAKE_CROSSCOMPILING) 30 find_package(PkgConfig QUIET) 31 if (PkgConfig_FOUND) 32 pkg_check_modules(LIBUNWIND libunwind-generic>=1.3.0) 33 if(LIBUNWIND_FOUND) 34 add_definitions(-DBORINGSSL_HAVE_LIBUNWIND) 35 else() 36 message("libunwind not found. Disabling unwind tests.") 37 endif() 38 else() 39 message("pkgconfig not found. Disabling unwind tests.") 40 endif() 41endif() 42 43string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER) 44if(NOT FIPS) 45 if(CMAKE_BUILD_TYPE_LOWER STREQUAL "relwithassert" OR 46 NOT CMAKE_BUILD_TYPE_LOWER MATCHES "rel") 47 add_definitions(-DBORINGSSL_DISPATCH_TEST) 48 # CMake automatically connects include_directories to the NASM 49 # command-line, but not add_definitions. 50 set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DBORINGSSL_DISPATCH_TEST") 51 endif() 52endif() 53 54# Add a RelWithAsserts build configuration. It is the same as Release, except it 55# does not define NDEBUG, so asserts run. 56foreach(VAR CMAKE_C_FLAGS CMAKE_CXX_FLAGS CMAKE_ASM_FLAGS) 57 string(REGEX REPLACE "(^| )[/-]DNDEBUG( |$)" " " "${VAR}_RELWITHASSERTS" 58 "${${VAR}_RELEASE}") 59endforeach() 60 61if(BORINGSSL_PREFIX AND BORINGSSL_PREFIX_SYMBOLS) 62 require_go() 63 add_definitions(-DBORINGSSL_PREFIX=${BORINGSSL_PREFIX}) 64 # CMake automatically connects include_directories to the NASM command-line, 65 # but not add_definitions. 66 set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DBORINGSSL_PREFIX=${BORINGSSL_PREFIX}") 67 68 # Use "symbol_prefix_include" to store generated header files 69 include_directories(${CMAKE_CURRENT_BINARY_DIR}/symbol_prefix_include) 70 add_custom_command( 71 OUTPUT symbol_prefix_include/boringssl_prefix_symbols.h 72 symbol_prefix_include/boringssl_prefix_symbols_asm.h 73 symbol_prefix_include/boringssl_prefix_symbols_nasm.inc 74 COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/symbol_prefix_include 75 COMMAND ${GO_EXECUTABLE} run ${CMAKE_CURRENT_SOURCE_DIR}/util/make_prefix_headers.go -out ${CMAKE_CURRENT_BINARY_DIR}/symbol_prefix_include ${BORINGSSL_PREFIX_SYMBOLS} 76 DEPENDS util/make_prefix_headers.go 77 ${BORINGSSL_PREFIX_SYMBOLS}) 78 79 # add_dependencies needs a target, not a file, so we add an intermediate 80 # target. 81 add_custom_target( 82 boringssl_prefix_symbols 83 DEPENDS symbol_prefix_include/boringssl_prefix_symbols.h 84 symbol_prefix_include/boringssl_prefix_symbols_asm.h 85 symbol_prefix_include/boringssl_prefix_symbols_nasm.inc) 86elseif(BORINGSSL_PREFIX OR BORINGSSL_PREFIX_SYMBOLS) 87 message(FATAL_ERROR "Must specify both or neither of BORINGSSL_PREFIX and BORINGSSL_PREFIX_SYMBOLS") 88else() 89 add_custom_target(boringssl_prefix_symbols) 90endif() 91 92if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") 93 set(CLANG 1) 94endif() 95 96if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten") 97 set(EMSCRIPTEN 1) 98endif() 99 100set(CMAKE_CXX_STANDARD 14) 101set(CMAKE_CXX_STANDARD_REQUIRED ON) 102set(CMAKE_C_STANDARD 11) 103set(CMAKE_C_STANDARD_REQUIRED ON) 104 105if(CMAKE_COMPILER_IS_GNUCXX OR CLANG) 106 # Note clang-cl is odd and sets both CLANG and MSVC. We base our configuration 107 # primarily on our normal Clang one. 108 set(C_CXX_FLAGS "-Werror -Wformat=2 -Wsign-compare -Wwrite-strings -Wvla -Wshadow -Wtype-limits -Wmissing-field-initializers") 109 if(MSVC) 110 # clang-cl sets different default warnings than clang. It also treats -Wall 111 # as -Weverything, to match MSVC. Instead -W3 is the alias for -Wall. 112 # See http://llvm.org/viewvc/llvm-project?view=revision&revision=319116 113 set(C_CXX_FLAGS "${C_CXX_FLAGS} -W3 -Wno-unused-parameter -fmsc-version=1900") 114 else() 115 if(EMSCRIPTEN) 116 # emscripten's emcc/clang does not accept the "-ggdb" flag. 117 set(C_CXX_FLAGS "${C_CXX_FLAGS} -g") 118 else() 119 set(C_CXX_FLAGS "${C_CXX_FLAGS} -ggdb") 120 endif() 121 122 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wall -fvisibility=hidden -fno-common") 123 endif() 124 125 if(CLANG) 126 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wnewline-eof -fcolor-diagnostics") 127 else() 128 # GCC (at least 4.8.4) has a bug where it'll find unreachable free() calls 129 # and declare that the code is trying to free a stack pointer. 130 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wno-free-nonheap-object") 131 endif() 132 133 # -Wstring-concatenation was added in Clang 12.0.0, which corresponds to 134 # AppleClang 13.0.0 per the table in 135 # https://en.wikipedia.org/wiki/Xcode#Toolchain_versions 136 if((CMAKE_C_COMPILER_ID STREQUAL "Clang" AND 137 CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0") OR 138 (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND 139 CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "13.0.0")) 140 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wstring-concatenation") 141 endif() 142 143 # Clang 12's -Wframe-larger-than reportedly does not work in clang-cl. See 144 # https://crbug.com/boringssl/709. Clang 13 includes the following fix, which 145 # may be related. Speculatively gate on Clang 13. That corresponds to 146 # AppleClang 13.1.6. 147 # https://github.com/llvm/llvm-project/commit/6aaf4fa2885600b0e31042071ad06f78218ab0f2 148 if((CMAKE_C_COMPILER_ID STREQUAL "Clang" AND 149 CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "13.0.0") OR 150 (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND 151 CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "13.1.6")) 152 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wframe-larger-than=25344") 153 endif() 154 155 if(CLANG OR CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "7.0.0") 156 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wimplicit-fallthrough") 157 endif() 158 159 if(CMAKE_COMPILER_IS_GNUCXX) 160 set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wformat-signedness") 161 endif() 162 163 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_CXX_FLAGS} -Wmissing-prototypes -Wold-style-definition -Wstrict-prototypes") 164 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${C_CXX_FLAGS} -Wmissing-declarations") 165 166 # In GCC, -Wmissing-declarations is the C++ spelling of -Wmissing-prototypes 167 # and using the wrong one is an error. In Clang, -Wmissing-prototypes is the 168 # spelling for both and -Wmissing-declarations is some other warning. 169 # 170 # https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Warning-Options.html#Warning-Options 171 # https://clang.llvm.org/docs/DiagnosticsReference.html#wmissing-prototypes 172 # https://clang.llvm.org/docs/DiagnosticsReference.html#wmissing-declarations 173 if(CLANG) 174 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wmissing-prototypes") 175 endif() 176elseif(MSVC) 177 set(MSVC_DISABLED_WARNINGS_LIST 178 "C4100" # 'exarg' : unreferenced formal parameter 179 "C4127" # conditional expression is constant 180 "C4244" # 'function' : conversion from 'int' to 'uint8_t', 181 # possible loss of data 182 "C4267" # conversion from 'size_t' to 'int', possible loss of data 183 "C4706" # assignment within conditional expression 184 ) 185 string(REPLACE "C" " -wd" MSVC_DISABLED_WARNINGS_STR 186 ${MSVC_DISABLED_WARNINGS_LIST}) 187 set(CMAKE_C_FLAGS "-utf-8 -W4 -WX ${MSVC_DISABLED_WARNINGS_STR}") 188 # Without /Zc:__cplusplus, MSVC does not define the right value for 189 # __cplusplus. See https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/ 190 # If this becomes too problematic for downstream code, we can look at 191 # _MSVC_LANG. 192 set(CMAKE_CXX_FLAGS "-utf-8 -W4 -WX ${MSVC_DISABLED_WARNINGS_STR} -Zc:__cplusplus") 193endif() 194 195if(WIN32) 196 add_definitions(-D_HAS_EXCEPTIONS=0) 197 add_definitions(-DWIN32_LEAN_AND_MEAN) 198 add_definitions(-DNOMINMAX) 199 # Allow use of fopen. 200 add_definitions(-D_CRT_SECURE_NO_WARNINGS) 201endif() 202 203# pthread_rwlock_t on Linux requires a feature flag. We limit this to Linux 204# because, on Apple platforms, it instead disables APIs we use. See compat(5) 205# and sys/cdefs.h. Reportedly, FreeBSD also breaks when this is set. See 206# https://crbug.com/boringssl/471. 207if(CMAKE_SYSTEM_NAME STREQUAL "Linux") 208 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_XOPEN_SOURCE=700") 209endif() 210 211if(FUZZ) 212 if(NOT CLANG) 213 message(FATAL_ERROR "You need to build with Clang for fuzzing to work") 214 endif() 215 216 if(CMAKE_C_COMPILER_VERSION VERSION_LESS "6.0.0") 217 message(FATAL_ERROR "You need Clang ≥ 6.0.0") 218 endif() 219 220 add_definitions(-DBORINGSSL_UNSAFE_DETERMINISTIC_MODE) 221 set(RUNNER_ARGS "-deterministic") 222 223 if(NOT NO_FUZZER_MODE) 224 add_definitions(-DBORINGSSL_UNSAFE_FUZZER_MODE) 225 set(RUNNER_ARGS ${RUNNER_ARGS} "-fuzzer" "-shim-config" "fuzzer_mode.json") 226 endif() 227 228 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address,fuzzer-no-link -fsanitize-coverage=edge,indirect-calls") 229 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,fuzzer-no-link -fsanitize-coverage=edge,indirect-calls") 230endif() 231 232add_definitions(-DBORINGSSL_IMPLEMENTATION) 233 234if(BUILD_SHARED_LIBS) 235 add_definitions(-DBORINGSSL_SHARED_LIBRARY) 236 # Enable position-independent code globally. This is needed because 237 # some library targets are OBJECT libraries. 238 set(CMAKE_POSITION_INDEPENDENT_CODE TRUE) 239endif() 240 241if(MSAN) 242 if(NOT CLANG) 243 message(FATAL_ERROR "Cannot enable MSAN unless using Clang") 244 endif() 245 246 if(ASAN) 247 message(FATAL_ERROR "ASAN and MSAN are mutually exclusive") 248 endif() 249 250 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer") 251 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer") 252 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer") 253endif() 254 255if(ASAN) 256 if(NOT CLANG) 257 message(FATAL_ERROR "Cannot enable ASAN unless using Clang") 258 endif() 259 260 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope -fno-omit-frame-pointer") 261 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope -fno-omit-frame-pointer") 262endif() 263 264if(CFI) 265 if(NOT CLANG) 266 message(FATAL_ERROR "Cannot enable CFI unless using Clang") 267 endif() 268 269 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=cfi -fno-sanitize-trap=cfi -flto=thin") 270 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=cfi -fno-sanitize-trap=cfi -flto=thin") 271 # We use Chromium's copy of clang, which requires -fuse-ld=lld if building 272 # with -flto. That, in turn, can't handle -ggdb. 273 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=lld") 274 string(REPLACE "-ggdb" "-g" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") 275 string(REPLACE "-ggdb" "-g" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") 276 # -flto causes object files to contain LLVM bitcode. Mixing those with 277 # assembly output in the same static library breaks the linker. 278 set(OPENSSL_NO_ASM "1") 279endif() 280 281if(TSAN) 282 if(NOT CLANG) 283 message(FATAL_ERROR "Cannot enable TSAN unless using Clang") 284 endif() 285 286 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread") 287 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread") 288 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread") 289endif() 290 291if(UBSAN) 292 if(NOT CLANG) 293 message(FATAL_ERROR "Cannot enable UBSAN unless using Clang") 294 endif() 295 296 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined") 297 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined") 298 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined") 299 300 if(NOT UBSAN_RECOVER) 301 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-sanitize-recover=undefined") 302 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-sanitize-recover=undefined") 303 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-sanitize-recover=undefined") 304 endif() 305endif() 306 307if(GCOV) 308 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage") 309 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") 310endif() 311 312if(FIPS) 313 require_go() 314 add_definitions(-DBORINGSSL_FIPS) 315 if(FIPS_BREAK_TEST) 316 add_definitions("-DBORINGSSL_FIPS_BREAK_${FIPS_BREAK_TEST}=1") 317 endif() 318 # The FIPS integrity check does not work for ASan and MSan builds. 319 if(NOT ASAN AND NOT MSAN) 320 if(BUILD_SHARED_LIBS) 321 set(FIPS_SHARED "1") 322 else() 323 set(FIPS_DELOCATE "1") 324 endif() 325 endif() 326 if(FIPS_SHARED) 327 # The Android CMake files set -ffunction-sections and -fdata-sections, 328 # which is incompatible with FIPS_SHARED. 329 set(CMAKE_C_FLAGS 330 "${CMAKE_C_FLAGS} -fno-function-sections -fno-data-sections") 331 set(CMAKE_CXX_FLAGS 332 "${CMAKE_CXX_FLAGS} -fno-function-sections -fno-data-sections") 333 endif() 334endif() 335 336if(OPENSSL_SMALL) 337 add_definitions(-DOPENSSL_SMALL) 338endif() 339 340if(CONSTANT_TIME_VALIDATION) 341 add_definitions(-DBORINGSSL_CONSTANT_TIME_VALIDATION) 342endif() 343 344if(MALLOC_FAILURE_TESTING) 345 add_definitions(-DBORINGSSL_MALLOC_FAILURE_TESTING) 346endif() 347 348if(OPENSSL_NO_ASM) 349 add_definitions(-DOPENSSL_NO_ASM) 350endif() 351 352if(FIPS_DELOCATE OR NOT OPENSSL_NO_ASM) 353 # On x86 and x86_64 Windows, we use the NASM output. 354 if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64|x86_64|amd64|x86|i[3-6]86") 355 enable_language(ASM_NASM) 356 set(OPENSSL_NASM TRUE) 357 set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -gcv8") 358 else() 359 enable_language(ASM) 360 set(OPENSSL_ASM TRUE) 361 # Work around https://gitlab.kitware.com/cmake/cmake/-/issues/20771 in older 362 # CMake versions. 363 if(APPLE AND CMAKE_VERSION VERSION_LESS 3.19) 364 if(CMAKE_OSX_SYSROOT) 365 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -isysroot \"${CMAKE_OSX_SYSROOT}\"") 366 endif() 367 foreach(arch ${CMAKE_OSX_ARCHITECTURES}) 368 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -arch ${arch}") 369 endforeach() 370 endif() 371 if(NOT WIN32) 372 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -Wa,--noexecstack") 373 endif() 374 # Clang's integerated assembler does not support debug symbols. 375 if(NOT CMAKE_ASM_COMPILER_ID MATCHES "Clang") 376 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -Wa,-g") 377 endif() 378 endif() 379endif() 380 381if(OPENSSL_NO_SSE2_FOR_TESTING) 382 add_definitions(-DOPENSSL_NO_SSE2_FOR_TESTING) 383endif() 384 385if(USE_CUSTOM_LIBCXX) 386 if(NOT CLANG) 387 message(FATAL_ERROR "USE_CUSTOM_LIBCXX only supported with Clang") 388 endif() 389 390 # CMake does not allow installing a library without installing dependencies. 391 # If we installed libcrypto, we'd have to install our custom libc++, which 392 # does not make sense. As this is a test-only configuration, disable 393 # installing. 394 set(INSTALL_ENABLED 0) 395 396 # CMAKE_CXX_FLAGS ends up in the linker flags as well, so use 397 # add_compile_options. There does not appear to be a way to set 398 # language-specific compile-only flags. 399 add_compile_options("-nostdinc++") 400 set(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -nostdlib++") 401 include_directories( 402 SYSTEM 403 util/bot/libcxx-config 404 util/bot/libcxx/include 405 util/bot/libcxxabi/include 406 ) 407 408 # This is patterned after buildtools/third_party/libc++/BUILD.gn and 409 # buildtools/third_party/libc++abi/BUILD.gn in Chromium. 410 411 file(GLOB LIBCXX_SOURCES "util/bot/libcxx/src/*.cpp") 412 file(GLOB LIBCXXABI_SOURCES "util/bot/libcxxabi/src/*.cpp") 413 414 # This file is meant for exception-less builds. 415 list(REMOVE_ITEM LIBCXXABI_SOURCES "trunk/src/cxa_noexception.cpp") 416 # libc++ also defines new and delete. 417 list(REMOVE_ITEM LIBCXXABI_SOURCES "trunk/src/stdlib_new_delete.cpp") 418 if(TSAN) 419 # ThreadSanitizer tries to intercept these symbols. Skip them to avoid 420 # symbol conflicts. 421 list(REMOVE_ITEM LIBCXXABI_SOURCES "trunk/src/cxa_guard.cpp") 422 endif() 423 424 add_library(libcxxabi ${LIBCXXABI_SOURCES}) 425 target_compile_definitions( 426 libcxxabi PRIVATE 427 -D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS 428 ) 429 430 add_library(libcxx ${LIBCXX_SOURCES}) 431 if(ASAN OR MSAN OR TSAN) 432 # Sanitizers try to intercept new and delete. 433 target_compile_definitions( 434 libcxx PRIVATE 435 -D_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS 436 ) 437 endif() 438 target_compile_definitions( 439 libcxx PRIVATE 440 -D_LIBCPP_BUILDING_LIBRARY 441 -DLIBCXX_BUILDING_LIBCXXABI 442 ) 443 set_target_properties( 444 libcxx libcxxabi PROPERTIES 445 COMPILE_FLAGS "-Wno-missing-prototypes -Wno-implicit-fallthrough" 446 # libc++ and libc++abi must be built in C++20 mode. 447 CXX_STANDARD 20 448 CXX_STANDARD_REQUIRED TRUE 449 ) 450 # libc++abi depends on libc++ internal headers. 451 set_property(TARGET libcxx libcxxabi APPEND PROPERTY INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/util/bot/libcxx/src") 452 target_link_libraries(libcxx libcxxabi) 453endif() 454 455# Add minimal googletest targets. The provided one has many side-effects, and 456# googletest has a very straightforward build. 457add_library( 458 boringssl_gtest 459 third_party/googletest/googlemock/src/gmock-all.cc 460 third_party/googletest/googletest/src/gtest-all.cc 461) 462if(USE_CUSTOM_LIBCXX) 463 target_link_libraries(boringssl_gtest libcxx) 464endif() 465target_include_directories( 466 boringssl_gtest 467 PUBLIC 468 third_party/googletest/googlemock/include 469 third_party/googletest/googletest/include 470 PRIVATE 471 third_party/googletest/googlemock 472 third_party/googletest/googletest 473) 474 475# Declare a dummy target to build all unit tests. Test targets should inject 476# themselves as dependencies next to the target definition. 477add_custom_target(all_tests) 478 479add_subdirectory(ssl/test) 480add_subdirectory(util/fipstools) 481add_subdirectory(util/fipstools/acvp/modulewrapper) 482 483if(OPENSSL_ASM) 484 set(CRYPTO_SOURCES_ASM_USED ${CRYPTO_SOURCES_ASM}) 485 set(BCM_SOURCES_ASM_USED ${BCM_SOURCES_ASM}) 486 set(TEST_SUPPORT_SOURCES_ASM_USED ${TEST_SUPPORT_SOURCES_ASM}) 487elseif(OPENSSL_NASM) 488 set(CRYPTO_SOURCES_ASM_USED ${CRYPTO_SOURCES_NASM}) 489 set(BCM_SOURCES_ASM_USED ${BCM_SOURCES_NASM}) 490 set(TEST_SUPPORT_SOURCES_ASM_USED ${TEST_SUPPORT_SOURCES_NASM}) 491endif() 492 493if(FIPS_DELOCATE AND FIPS_SHARED) 494 message(FATAL_ERROR "Can't set both delocate and shared mode for FIPS build") 495endif() 496 497if(FIPS_DELOCATE) 498 add_library(bcm_c_generated_asm STATIC ${BCM_SOURCES}) 499 add_dependencies(bcm_c_generated_asm boringssl_prefix_symbols) 500 target_include_directories(bcm_c_generated_asm PRIVATE ${PROJECT_SOURCE_DIR}/include) 501 set_target_properties(bcm_c_generated_asm PROPERTIES COMPILE_OPTIONS "-S") 502 set_target_properties(bcm_c_generated_asm PROPERTIES POSITION_INDEPENDENT_CODE ON) 503 504 set(TARGET_FLAG "") 505 if(CMAKE_ASM_COMPILER_TARGET) 506 set(TARGET_FLAG "--target=${CMAKE_ASM_COMPILER_TARGET}") 507 endif() 508 509 go_executable(delocate boringssl.googlesource.com/boringssl/util/fipstools/delocate) 510 add_custom_command( 511 OUTPUT bcm-delocated.S 512 COMMAND ${CMAKE_CURRENT_BINARY_DIR}/delocate 513 -a $<TARGET_FILE:bcm_c_generated_asm> 514 -o ${CMAKE_CURRENT_BINARY_DIR}/bcm-delocated.S 515 -cc ${CMAKE_ASM_COMPILER} 516 -cc-flags "${TARGET_FLAG} ${CMAKE_ASM_FLAGS}" 517 ${BCM_SOURCES_ASM_USED} 518 ${CRYPTO_HEADERS} 519 DEPENDS bcm_c_generated_asm 520 delocate 521 ${BCM_SOURCES_ASM_USED} 522 ${CRYPTO_HEADERS} 523 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} 524 ) 525 526 add_library(bcm_hashunset STATIC bcm-delocated.S) 527 set_target_properties(bcm_hashunset PROPERTIES POSITION_INDEPENDENT_CODE ON) 528 set_target_properties(bcm_hashunset PROPERTIES LINKER_LANGUAGE C) 529 530 go_executable(inject_hash 531 boringssl.googlesource.com/boringssl/util/fipstools/inject_hash) 532 add_custom_command( 533 OUTPUT bcm.o 534 COMMAND ./inject_hash -o bcm.o -in-archive $<TARGET_FILE:bcm_hashunset> 535 DEPENDS bcm_hashunset inject_hash 536 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} 537 ) 538 set(CRYPTO_FIPS_OBJECTS bcm.o) 539elseif(FIPS_SHARED) 540 if(NOT BUILD_SHARED_LIBS) 541 message(FATAL_ERROR "FIPS_SHARED set but not BUILD_SHARED_LIBS") 542 endif() 543 544 add_library(bcm_library STATIC ${BCM_SOURCES} ${BCM_SOURCES_ASM_USED}) 545 add_dependencies(bcm_library boringssl_prefix_symbols) 546 target_include_directories(bcm_library PRIVATE ${PROJECT_SOURCE_DIR}/include) 547 548 add_custom_command( 549 OUTPUT bcm.o 550 COMMAND ${CMAKE_LINKER} -r -T ${CMAKE_CURRENT_SOURCE_DIR}/crypto/fipsmodule/fips_shared.lds -o bcm.o --whole-archive $<TARGET_FILE:bcm_library> 551 DEPENDS bcm_library crypto/fipsmodule/fips_shared.lds 552 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} 553 ) 554 set(CRYPTO_FIPS_OBJECTS bcm.o) 555else() 556 add_library(fipsmodule OBJECT ${BCM_SOURCES} ${BCM_SOURCES_ASM_USED}) 557 add_dependencies(fipsmodule boringssl_prefix_symbols) 558 target_include_directories(fipsmodule PRIVATE ${PROJECT_SOURCE_DIR}/include) 559 set(CRYPTO_FIPS_OBJECTS $<TARGET_OBJECTS:fipsmodule>) 560endif() 561 562add_library(crypto ${CRYPTO_SOURCES} ${CRYPTO_FIPS_OBJECTS} ${CRYPTO_SOURCES_ASM_USED}) 563target_include_directories(crypto PUBLIC 564 $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include> 565 $<INSTALL_INTERFACE:include> 566) 567set_property(TARGET crypto PROPERTY EXPORT_NAME Crypto) 568 569if(FIPS_SHARED) 570 # Rewrite libcrypto.so to inject the correct module hash value. This assumes 571 # UNIX-style library naming, but we only support FIPS mode on Linux anyway. 572 add_custom_command( 573 TARGET crypto POST_BUILD 574 COMMAND ${GO_EXECUTABLE} run 575 ${CMAKE_CURRENT_SOURCE_DIR}/util/fipstools/inject_hash/inject_hash.go 576 -o libcrypto.so -in-object libcrypto.so 577 # The DEPENDS argument to a POST_BUILD rule appears to be ignored. Thus 578 # go_executable isn't used (as it doesn't get built), but we list this 579 # dependency anyway in case it starts working in some CMake version. 580 DEPENDS util/fipstools/inject_hash/inject_hash.go 581 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} 582 ) 583endif() 584 585add_dependencies(crypto boringssl_prefix_symbols) 586if(WIN32) 587 target_link_libraries(crypto ws2_32) 588endif() 589 590# CMAKE_SYSTEM_NAME is "Generic" for embedded OSes: 591# https://cmake.org/cmake/help/book/mastering-cmake/chapter/Cross%20Compiling%20With%20CMake.html#toolchain-files 592# 593# For now we assume embedded OSes do not have threads. Additionally, the Threads 594# package does not work with Android, but Android does not require any extra 595# parameters to link pthreads. 596if(NOT CMAKE_SYSTEM_NAME MATCHES "^(Generic|Android)$") 597 find_package(Threads REQUIRED) 598 target_link_libraries(crypto Threads::Threads) 599endif() 600 601# Every target depends on crypto, so we add libcxx as a dependency here to 602# simplify injecting it everywhere. 603if(USE_CUSTOM_LIBCXX) 604 target_link_libraries(crypto libcxx) 605endif() 606 607add_library(ssl ${SSL_SOURCES}) 608# Although libssl also provides headers that require an include directory, the 609# flag is already specified by libcrypto, so we omit target_include_directories 610# here. 611set_property(TARGET ssl PROPERTY EXPORT_NAME SSL) 612target_link_libraries(ssl crypto) 613 614add_library(decrepit ${DECREPIT_SOURCES}) 615target_link_libraries(decrepit crypto ssl) 616 617add_library(test_support_lib STATIC 618 ${TEST_SUPPORT_SOURCES} ${TEST_SUPPORT_SOURCES_ASM_USED}) 619if(LIBUNWIND_FOUND) 620 target_compile_options(test_support_lib PRIVATE ${LIBUNWIND_CFLAGS_OTHER}) 621 target_include_directories(test_support_lib PRIVATE ${LIBUNWIND_INCLUDE_DIRS}) 622 target_link_libraries(test_support_lib ${LIBUNWIND_LDFLAGS}) 623endif() 624if(WIN32) 625 target_link_libraries(test_support_lib dbghelp) 626endif() 627target_link_libraries(test_support_lib boringssl_gtest crypto) 628 629# urandom_test is a separate binary because it needs to be able to observe the 630# PRNG initialisation, which means that it can't have other tests running before 631# it does. 632add_executable(urandom_test ${URANDOM_TEST_SOURCES}) 633target_link_libraries(urandom_test test_support_lib boringssl_gtest crypto) 634add_dependencies(all_tests urandom_test) 635 636add_executable(crypto_test ${CRYPTO_TEST_SOURCES}) 637target_link_libraries(crypto_test test_support_lib boringssl_gtest crypto) 638add_dependencies(all_tests crypto_test) 639 640add_executable(ssl_test ${SSL_TEST_SOURCES}) 641target_link_libraries(ssl_test test_support_lib boringssl_gtest ssl crypto) 642add_dependencies(all_tests ssl_test) 643add_executable(decrepit_test ${DECREPIT_TEST_SOURCES}) 644target_link_libraries(decrepit_test test_support_lib boringssl_gtest 645 decrepit crypto) 646add_dependencies(all_tests decrepit_test) 647 648if(APPLE) 649 set(PKI_CXX_FLAGS "-fno-aligned-new") 650endif() 651 652add_library(pki ${PKI_SOURCES}) 653target_link_libraries(pki crypto) 654 655add_executable(pki_test ${PKI_TEST_SOURCES}) 656target_link_libraries(pki_test test_support_lib boringssl_gtest pki crypto) 657add_dependencies(all_tests pki_test) 658 659# The PKI library requires C++17. 660set_target_properties( 661 pki pki_test 662 PROPERTIES 663 CXX_STANDARD 17 664 CXX_STANDARD_REQUIRED YES 665 COMPILE_FLAGS "${PKI_CXX_FLAGS}") 666 667add_executable(bssl ${BSSL_SOURCES}) 668target_link_libraries(bssl ssl crypto) 669 670# Historically, targets were built in subdirectories. For compatibility with 671# existing tools, we, for now, copy the targets into the subdirectories. This 672# will be removed sometime in 2024. 673copy_post_build(crypto crypto crypto_test urandom_test) 674copy_post_build(ssl ssl ssl_test) 675copy_post_build(decrepit decrepit decrepit_test) 676copy_post_build(tool bssl) 677 678if(FUZZ) 679 if(LIBFUZZER_FROM_DEPS) 680 file(GLOB LIBFUZZER_SOURCES "util/bot/libFuzzer/*.cpp") 681 add_library(Fuzzer STATIC ${LIBFUZZER_SOURCES}) 682 # libFuzzer does not pass our aggressive warnings. It also must be built 683 # without -fsanitize-coverage options or clang crashes. 684 set_target_properties(Fuzzer PROPERTIES COMPILE_FLAGS "-Wno-shadow -Wno-format-nonliteral -Wno-missing-prototypes -fsanitize-coverage=0") 685 endif() 686 687 add_subdirectory(fuzz) 688endif() 689 690if(RUST_BINDINGS) 691 find_program(BINDGEN_EXECUTABLE bindgen) 692 if(NOT BINDGEN_EXECUTABLE) 693 message(FATAL_ERROR "Could not find bindgen but was asked to generate Rust bindings.") 694 else() 695 add_subdirectory(rust) 696 endif() 697endif() 698 699if(CMAKE_SYSTEM_NAME STREQUAL "Linux") 700 set(HANDSHAKER_ARGS "-handshaker-path" $<TARGET_FILE:handshaker>) 701endif() 702 703if(FIPS) 704 add_custom_target( 705 acvp_tests 706 COMMAND ${GO_EXECUTABLE} build -o ${CMAKE_CURRENT_BINARY_DIR}/acvptool 707 boringssl.googlesource.com/boringssl/util/fipstools/acvp/acvptool 708 COMMAND ${GO_EXECUTABLE} build -o ${CMAKE_CURRENT_BINARY_DIR}/testmodulewrapper 709 boringssl.googlesource.com/boringssl/util/fipstools/acvp/acvptool/testmodulewrapper 710 COMMAND cd util/fipstools/acvp/acvptool/test && 711 ${GO_EXECUTABLE} run check_expected.go 712 -tool ${CMAKE_CURRENT_BINARY_DIR}/acvptool 713 -module-wrappers modulewrapper:$<TARGET_FILE:modulewrapper>,testmodulewrapper:${CMAKE_CURRENT_BINARY_DIR}/testmodulewrapper 714 -tests tests.json 715 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} 716 DEPENDS modulewrapper 717 USES_TERMINAL) 718 719 add_custom_target( 720 fips_specific_tests_if_any 721 DEPENDS acvp_tests 722 ) 723else() 724 add_custom_target(fips_specific_tests_if_any) 725endif() 726 727file(STRINGS util/go_tests.txt GO_TESTS) 728set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS 729 util/go_tests.txt) 730 731if(GO_EXECUTABLE) 732 add_custom_target( 733 run_tests 734 COMMAND ${CMAKE_COMMAND} -E echo "Running Go tests" 735 COMMAND ${GO_EXECUTABLE} test ${GO_TESTS} 736 COMMAND ${CMAKE_COMMAND} -E echo 737 COMMAND ${CMAKE_COMMAND} -E echo "Running unit tests" 738 COMMAND ${GO_EXECUTABLE} run util/all_tests.go -build-dir 739 ${CMAKE_CURRENT_BINARY_DIR} 740 COMMAND ${CMAKE_COMMAND} -E echo 741 COMMAND ${CMAKE_COMMAND} -E echo "Running SSL tests" 742 COMMAND cd ssl/test/runner && 743 ${GO_EXECUTABLE} test -shim-path $<TARGET_FILE:bssl_shim> 744 ${HANDSHAKER_ARGS} ${RUNNER_ARGS} 745 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} 746 DEPENDS all_tests bssl_shim handshaker fips_specific_tests_if_any 747 USES_TERMINAL) 748else() 749 add_custom_target( 750 run_tests 751 COMMAND ${CMAKE_COMMAND} -E echo "Running tests requires Go" 752 COMMAND ${CMAKE_COMMAND} -E false) 753endif() 754 755if(INSTALL_ENABLED) 756 # CMake versions before 3.14 do not have default destination values. Executable 757 # and library targets that use a default destination should include this 758 # variable. 759 if(CMAKE_VERSION VERSION_LESS "3.14") 760 set(INSTALL_DESTINATION_DEFAULT 761 ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} 762 LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} 763 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) 764 endif() 765 766 install(TARGETS crypto ssl 767 EXPORT OpenSSLTargets ${INSTALL_DESTINATION_DEFAULT}) 768 install(TARGETS bssl DESTINATION ${INSTALL_DESTINATION_DEFAULT}) 769 install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) 770 install(EXPORT OpenSSLTargets 771 FILE OpenSSLTargets.cmake 772 NAMESPACE OpenSSL:: 773 DESTINATION lib/cmake/OpenSSL) 774 install(FILES cmake/OpenSSLConfig.cmake DESTINATION lib/cmake/OpenSSL) 775endif() 776