kris/pqc
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity
2ce8a28e41
pqc/CMakeLists.txt

398 lines
14 KiB
CMake
Raw Normal View History

init: cmake
2021-02-10 00:21:31 +00:00
cmake_minimum_required(VERSION 3.13)
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
project(cryptocore VERSION 0.0.1 LANGUAGES C)
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
include(FetchContent)
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
include(ExternalProject)
init: cmake
2021-02-10 00:21:31 +00:00
updates gbench
2021-06-14 21:11:07 +01:00
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_C_STANDARD 99)
adds fpic
2021-06-14 21:16:14 +01:00
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
updates gbench
2021-06-14 21:11:07 +01:00
init: cmake
2021-02-10 00:21:31 +00:00
enable_language(C)
enable_language(CXX)
enable_language(ASM)
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
if(MEMSAN)
# PQC_MEMSAN enables usage of some internals from clang
if (NOT CMAKE_C_COMPILER_ID MATCHES "Clang")
message(FATAL_ERROR "Must use clang if compiled with memory sanitizer.")
endif()
if(ADDRSAN)
message(FATAL_ERROR "Can't use MSAN and ASAN")
endif()
improves makefile
2021-06-22 01:10:08 +01:00
include(.cmake/libstd-memory_sanitizer.mk)
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
# LLVM project location
set(LLVM_PRJ ${CMAKE_CURRENT_BINARY_DIR}/3rd/llvm-project)
set(LLVM_PRJ_LIB ${LLVM_PRJ}/usr/local/lib)
set(LLVM_PRJ_INC ${LLVM_PRJ}/usr/local/include)
# Add memory sanitizer instrumented libraries
improves makefile
2021-06-22 01:10:08 +01:00
set(CMAKE_ARGS_MEMCHECK_LIB "-stdlib=libc++")
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
set(CMAKE_ARGS_MEMCHECK_INC "-isystem -I${LLVM_PRJ_INC} -I${LLVM_PRJ_INC}/c++/v1")
set(CMAKE_ARGS_MEMCHECK_FLAGS "-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -Wno-unused-command-line-argument")
makes MSan happy
2021-06-21 09:20:48 +01:00
set(EXTRA_CXX_FLAGS "${CMAKE_ARGS_MEMCHECK_FLAGS} ${CMAKE_ARGS_MEMCHECK_LIB} ${CMAKE_ARGS_MEMCHECK_INC} -DPQC_MEMSAN_BUILD")
fix build
2021-06-22 01:14:17 +01:00
set(CXXLIBS_FOR_MEMORY_SANITIZER cxx cxxabi)
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
endif()
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
# Dependencies
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
ExternalProject_Add(
gtest_project
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
SOURCE_DIR ${PROJECT_SOURCE_DIR}/3rd/gtest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG a3460d1aeeaa43fdf137a6adefef10ba0b59fe4b
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
PREFIX ${CMAKE_CURRENT_BINARY_DIR}/3rd/gtest
INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/3rd/gtest
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_CURRENT_BINARY_DIR}/3rd/gtest -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_CXX_FLAGS=${EXTRA_CXX_FLAGS} -DCMAKE_C_FLAGS=${EXTRA_CXX_FLAGS} -Dgtest_disable_pthreads=ON
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
)
fix build
2021-06-22 01:14:17 +01:00
if(MEMSAN)
add_dependencies(gtest_project ${CXXLIBS_FOR_MEMORY_SANITIZER})
endif()
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
FetchContent_Declare(
gbench
SOURCE_DIR ${PROJECT_SOURCE_DIR}/3rd/gbench
GIT_REPOSITORY https://github.com/kriskwiatkowski/benchmark.git
updates gbench
2021-06-14 21:11:07 +01:00
GIT_TAG 49862ab56b6b7c3afd87b80bd5d787ed78ce3b96
Build libcxx and libcxxabi with Memory Sanitizer
2021-06-17 08:27:29 +01:00
GIT_SHALLOW TRUE
don't use submodules Use cmake FetchContent instead
2021-05-26 08:01:47 +01:00
)
FetchContent_Populate(gbench)
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
FetchContent_Declare(
cpu_features
SOURCE_DIR ${PROJECT_SOURCE_DIR}/3rd/cpu_features
GIT_REPOSITORY https://github.com/google/cpu_features.git
GIT_TAG bc2846e78faeb26b8a46c17df369d4e5f1f9e2bb
GIT_SHALLOW TRUE
)
FetchContent_Populate(cpu_features)
Build libcxx and libcxxabi with Memory Sanitizer
2021-06-17 08:27:29 +01:00
adds fpic
2021-06-14 21:16:14 +01:00
set(BUILD_PIC ON CACHE BOOL "")
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
add_subdirectory(3rd/cpu_features)
init: cmake
2021-02-10 00:21:31 +00:00
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "~/.cmake/Modules")
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "3rd/cmake-modules")
set(CMAKE_CXX_STANDARD 11)
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
init: cmake
2021-02-10 00:21:31 +00:00
string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)
if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86_64")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "amd64")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86_64")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86_64")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "i386")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "i686")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_x86")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_aarch64")
init: cmake
2021-02-10 00:21:31 +00:00
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "arm64")
Add one AVX target
2021-02-17 13:38:23 +00:00
set(ARCH "ARCH_aarch64")
init: cmake
2021-02-10 00:21:31 +00:00
else()
message(FATAL_ERROR "Unknown processor:" ${CMAKE_SYSTEM_PROCESSOR})
endif()
# Arch settings
if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
set(MACOSX TRUE)
endif()
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
# Additional flags only useful when compiling with clang
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
string(APPEND C_CXX_FLAGS " -Wconditional-uninitialized -Wno-missing-variable-declarations -Wno-unused-command-line-argument")
init: cmake
2021-02-10 00:21:31 +00:00
endif()
if (MACOSX)
set(CMAKE_C_COMPILER /usr/bin/cc CACHE PATH "" FORCE)
set(CMAKE_CXX_COMPILER /usr/bin/c++ CACHE PATH "" FORCE)
endif()
# Global configuration
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
set(C_CXX_FLAGS "${C_CXX_FLAGS} -Wno-ignored-qualifiers \
init: cmake
2021-02-10 00:21:31 +00:00
-Wall \
-Werror \
-Wextra \
-Wpedantic \
-Wshadow \
-Wno-variadic-macros \
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
-Wunused-result \
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
-Wno-unused-command-line-argument \
-Wno-undef \
${EXTRA_CXX_FLAGS}")
if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER_VERSION VERSION_GREATER 11.0)
set(C_CXX_FLAGS "${C_CXX_FLAGS} \
-Wno-stringop-overread \
-Wno-stringop-overflow \
-Wno-array-parameter")
endif()
init: cmake
2021-02-10 00:21:31 +00:00
Adds flags for memory and address sanitizer
2021-06-16 06:21:58 +01:00
# Build with address sanitizer
if(ADDRSAN)
set(C_CXX_FLAGS "${C_CXX_FLAGS} -fsanitize=undefined,address,leak -fno-omit-frame-pointer")
set(LDFLAGS "${LDFLAGS} -fsanitize=undefined,address,leak")
endif()
Use CMake
2021-03-03 06:50:25 +00:00
include(.cmake/common.mk)
init: cmake
2021-02-10 00:21:31 +00:00
# Control Debug/Release mode
if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug")
set(C_CXX_FLAGS "${C_CXX_FLAGS} -g3 -O0 -Wno-unused")
else()
set(C_CXX_FLAGS "${C_CXX_FLAGS} -O3")
endif()
include_directories(
pqapi.h -> pqc.h
2021-03-24 23:34:34 +00:00
public
Use CMake
2021-03-03 06:50:25 +00:00
src/common/
init: cmake
2021-02-10 00:21:31 +00:00
src
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
3rd/cpu_features/include
init: cmake
2021-02-10 00:21:31 +00:00
)
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
set_property(GLOBAL PROPERTY obj_libs "")
init: cmake
2021-02-10 00:21:31 +00:00
# Set CPU architecture
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
set(C_CXX_FLAGS "${C_CXX_FLAGS} -D${ARCH}")
# Build for haswell if on x86_64
if(${ARCH} STREQUAL "ARCH_x86_64")
string(APPEND C_CXX_FLAGS " -march=haswell")
endif()
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
set(PQC_CMAKE_C_FLAGS "${PQC_CMAKE_C_FLAGS} ${C_CXX_FLAGS}")
set(PQC_CMAKE_CXX_FLAGS "${PQC_CMAKE_CXX_FLAGS} ${C_CXX_FLAGS}")
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
set(CMAKE_C_FLAGS ${PQC_CMAKE_C_FLAGS})
set(CMAKE_CXX_FLAGS ${PQC_CMAKE_CXX_FLAGS})
init: cmake
2021-02-10 00:21:31 +00:00
Adds DRBG based on AES In order to enable all KAT tests, the AES based DRBG is need (for seed expansion). This PR adds port of DRBG, initialy written by NIST. Afterwards, the katrunner is modified to enable key generation, encapsulation and signing KATs. Testing of NTRU prime is disabled, as it doesn't pass KAT tests now. The tests for SPHINCS+ are now very slow.
2021-03-30 01:12:11 +01:00
if(PQC_WEAK_RANDOMBYTES)
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
string(APPEND PQC_CMAKE_C_FLAGS " -DPQC_WEAK_RANDOMBYTES")
Adds DRBG based on AES In order to enable all KAT tests, the AES based DRBG is need (for seed expansion). This PR adds port of DRBG, initialy written by NIST. Afterwards, the katrunner is modified to enable key generation, encapsulation and signing KATs. Testing of NTRU prime is disabled, as it doesn't pass KAT tests now. The tests for SPHINCS+ are now very slow.
2021-03-30 01:12:11 +01:00
endif()
Add one AVX target
2021-02-17 13:38:23 +00:00
# Define sources of the components
Use CMake
2021-03-03 06:50:25 +00:00
add_subdirectory(src/sign/dilithium/dilithium2/clean)
add_subdirectory(src/sign/dilithium/dilithium3/clean)
add_subdirectory(src/sign/dilithium/dilithium5/clean)
Implelments Falcon 512/1024 Round3 * Enable KAT testing for Falcon * Prefix all algorithms with PQC_ALG_SIG/KEM_
2021-05-25 08:20:31 +01:00
add_subdirectory(src/sign/falcon)
Use CMake
2021-03-03 06:50:25 +00:00
add_subdirectory(src/sign/rainbow/rainbowV-classic/clean)
add_subdirectory(src/sign/rainbow/rainbowI-classic/clean)
add_subdirectory(src/sign/rainbow/rainbowIII-classic/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192f-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128f-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128f-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128s-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256f-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256f-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128s-robust/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128f-simple/clean)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192f-robust/clean)
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
adds C-API
2021-03-23 09:25:18 +00:00
add_subdirectory(src/kem/kyber/kyber512/clean)
add_subdirectory(src/kem/kyber/kyber768/clean)
add_subdirectory(src/kem/kyber/kyber1024/clean)
add_subdirectory(src/kem/saber/lightsaber/clean)
add_subdirectory(src/kem/saber/firesaber/clean)
add_subdirectory(src/kem/saber/saber/clean)
add_subdirectory(src/kem/frodo/frodokem640shake/clean)
add_subdirectory(src/kem/frodo/frodokem976shake/clean)
add_subdirectory(src/kem/frodo/frodokem1344shake/clean)
add_subdirectory(src/kem/ntru/ntruhps4096821/clean)
add_subdirectory(src/kem/ntru/ntruhps2048509/clean)
add_subdirectory(src/kem/ntru/ntruhrss701/clean)
add_subdirectory(src/kem/ntru/ntruhps2048677/clean)
add_subdirectory(src/kem/ntru_prime/ntrulpr761/clean)
add_subdirectory(src/kem/ntru_prime/ntrulpr653/clean)
add_subdirectory(src/kem/ntru_prime/ntrulpr857/clean)
adds HQC-RMS-128/192/256
2021-03-27 00:34:03 +00:00
add_subdirectory(src/kem/hqc/hqc-rmrs-128/clean)
add_subdirectory(src/kem/hqc/hqc-rmrs-192/clean)
add_subdirectory(src/kem/hqc/hqc-rmrs-256/clean)
SIKE/p434 Pulls SIKE/p434 from CECPQ2 implementation changed to use SHAKE instead of SHA2
2021-04-06 23:41:01 +01:00
add_subdirectory(src/kem/sike)
adds McEliece
2021-05-26 13:09:25 +01:00
add_subdirectory(src/kem/mceliece/mceliece348864/clean)
add_subdirectory(src/kem/mceliece/mceliece460896/clean)
add_subdirectory(src/kem/mceliece/mceliece6688128/clean)
add_subdirectory(src/kem/mceliece/mceliece6960119/clean)
add_subdirectory(src/kem/mceliece/mceliece8192128/clean)
add_subdirectory(src/kem/mceliece/mceliece348864f/clean)
add_subdirectory(src/kem/mceliece/mceliece460896f/clean)
add_subdirectory(src/kem/mceliece/mceliece6688128f/clean)
add_subdirectory(src/kem/mceliece/mceliece6960119f/clean)
add_subdirectory(src/kem/mceliece/mceliece8192128f/clean)
adds C-API
2021-03-23 09:25:18 +00:00
# Hardware optimized targets
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
if(${ARCH} STREQUAL "ARCH_x86_64")
adds C-API
2021-03-23 09:25:18 +00:00
set(SRC_COMMON_AVX2
src/common/keccak4x/KeccakP-1600-times4-SIMD256.c
)
# Sign
Use CMake
2021-03-03 06:50:25 +00:00
add_subdirectory(src/sign/dilithium/dilithium2/avx2)
add_subdirectory(src/sign/dilithium/dilithium3/avx2)
add_subdirectory(src/sign/dilithium/dilithium5/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128s-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-128f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192s-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-192f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-shake256-256s-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128s-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-128f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192s-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-192f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256s-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256f-robust/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256f-simple/avx2)
add_subdirectory(src/sign/sphincs/sphincs-sha256-256s-robust/avx2)
adds C-API
2021-03-23 09:25:18 +00:00
# KEMs
Use CMake
2021-03-03 06:50:25 +00:00
add_subdirectory(src/kem/kyber/kyber512/avx2)
add_subdirectory(src/kem/kyber/kyber768/avx2)
add_subdirectory(src/kem/kyber/kyber1024/avx2)
add_subdirectory(src/kem/saber/lightsaber/avx2)
add_subdirectory(src/kem/saber/firesaber/avx2)
add_subdirectory(src/kem/saber/saber/avx2)
add_subdirectory(src/kem/ntru/ntruhps4096821/avx2)
add_subdirectory(src/kem/ntru/ntruhps2048509/avx2)
add_subdirectory(src/kem/ntru/ntruhrss701/avx2)
add_subdirectory(src/kem/ntru/ntruhps2048677/avx2)
add_subdirectory(src/kem/ntru_prime/ntrulpr761/avx2)
add_subdirectory(src/kem/ntru_prime/ntrulpr653/avx2)
add_subdirectory(src/kem/ntru_prime/ntrulpr857/avx2)
adds HQC-RMS-128/192/256
2021-03-27 00:34:03 +00:00
add_subdirectory(src/kem/hqc/hqc-rmrs-128/avx2)
add_subdirectory(src/kem/hqc/hqc-rmrs-192/avx2)
add_subdirectory(src/kem/hqc/hqc-rmrs-256/avx2)
Add one AVX target
2021-02-17 13:38:23 +00:00
endif()
adds C-API
2021-03-23 09:25:18 +00:00
# The rest of the library
set(SRC_COMMON_GENERIC
src/common/aes.c
src/common/fips202.c
src/common/sp800-185.c
src/common/randombytes.c
src/common/sha2.c
adds HQC-RMS-128/192/256
2021-03-27 00:34:03 +00:00
src/common/nistseedexpander.c
adds C-API
2021-03-23 09:25:18 +00:00
src/capi/pqapi.c
)
Use CMake
2021-03-03 06:50:25 +00:00
Add one AVX target
2021-02-17 13:38:23 +00:00
add_library(
common
OBJECT
${SRC_COMMON_GENERIC}
${SRC_COMMON_AVX2}
)
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
add_library(
change name of the librarry
2021-03-25 00:59:41 +00:00
pqc
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
SHARED
)
init: cmake
2021-02-10 00:21:31 +00:00
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
add_library(
change name of the librarry
2021-03-25 00:59:41 +00:00
pqc_s
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
STATIC
init: cmake
2021-02-10 00:21:31 +00:00
)
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
get_property(OBJ_LIBS GLOBAL PROPERTY obj_libs)
init: cmake
2021-02-10 00:21:31 +00:00
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
target_link_libraries(
change name of the librarry
2021-03-25 00:59:41 +00:00
pqc
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
${OBJ_LIBS}
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
cpu_features
common
init: cmake
2021-02-10 00:21:31 +00:00
)
target_link_libraries(
change name of the librarry
2021-03-25 00:59:41 +00:00
pqc_s
SIKE: enable optimized version Adds cpu_features library from Google to recognize CPU capabilities on which implementation is running. Uses that library to run either generic-C or assembly optimized implementation of some field operations
2021-04-14 08:04:14 +01:00
cpu_features
Defines structure of the CMake
2021-02-17 12:40:38 +00:00
common
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
${OBJ_LIBS}
init: cmake
2021-02-10 00:21:31 +00:00
)
Adds method registration
2021-03-23 09:31:12 +00:00
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
SET(UT_SRC test/ut.cpp)
if(MEMSAN)
SET(UT_SRC ${UT_SRC} test/ct.cpp)
endif()
Adds method registration
2021-03-23 09:31:12 +00:00
add_executable(
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
ut
adds address and memory sanitizer
2021-06-16 07:48:47 +01:00
${UT_SRC}
Adds method registration
2021-03-23 09:31:12 +00:00
)
target_link_libraries(
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
ut
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
Adds method registration
2021-03-23 09:31:12 +00:00
gtest
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
gtest_main
fix build
2021-06-22 01:14:17 +01:00
pqc_s
${CXXLIBS_FOR_MEMORY_SANITIZER})
Adds method registration
2021-03-23 09:31:12 +00:00
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
ExternalProject_Get_Property(gtest_project INSTALL_DIR)
Adds method registration
2021-03-23 09:31:12 +00:00
target_include_directories(
KEM and Sign C-API
2021-03-24 10:25:45 +00:00
ut PRIVATE
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
${CMAKE_SOURCE_DIR}
${INSTALL_DIR}/include)
target_link_directories(
ut
PRIVATE
${INSTALL_DIR}/lib)
# github CI requires that
add_dependencies(ut gtest_project)
Adds method registration
2021-03-23 09:31:12 +00:00
add benchmarking framework
2021-04-22 21:41:40 +01:00
if(NOT CMAKE_BUILD_TYPE_LOWER STREQUAL "debug")
Redesign CMakeLists.txt for MemorySanitizer The test programs use googletest and google-benchmark libraries in order to ensure right level of optimizations and proper unit testing. Those two libraries are written in C++ and they use C++ standard library. If you want MemorySanitizer to work properly and not produce any false positives, you must ensure that all the code in your program and in libraries it uses is instrumented. That includes C++ standard library. (see here: https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo) With this change, the Memory Sanitizer build (enabled by -DMEMSAN=1) will also build MSan-instrumented libc++ from LLVM and will use it as a standard C++ library when building unit tests and benchmarks. In particular what I do is this: 1. Clone LLVM project and build libcxx and libcxxabi with MSan enabled 2. Build GTEST and GBENCH with -fsanitize=memory and -stdlib=libc++. Additionally link against -lc++abi 3. Then use this special version of libc++ and GTEST/GBENCH in order to build final binaries containing unit/benchmark tests The actuall tests with memory sanitizer are disabled, as I'm getting some errors which need to be investigated first. Additionally I've splitted single build into multiple, for release,debug,clang,gcc and AddressSanitizer. On unrelated note, I've also added flags to ignore some errors which I'm getting when using newer GCC (see GH#10 GH#11).
2021-06-19 01:11:49 +01:00
# settings below are required by benchmark library
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
# Target for benchmark - it also builds gtest library
set(BENCHMARK_ENABLE_GTEST_TESTS ON CACHE BOOL "Enable testing of the benchmark library." FORCE)
set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "Disable benchmark tests" FORCE)
set(GOOGLETEST_PATH "${CMAKE_SOURCE_DIR}/3rd/gtest" CACHE PATH "Path to the gtest sources" FORCE)
#if (NOT MACOSX)
# set(BENCHMARK_ENABLE_LTO ON CACHE BOOL "Enable link time optim" FORCE)
#endif()
set(BENCHMARK_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
set(CMAKE_C_FLAGS "${C_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${C_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
add_subdirectory(${CMAKE_SOURCE_DIR}/3rd/gbench)
add_subdirectory(test/bench)
add benchmarking framework
2021-04-22 21:41:40 +01:00
endif()
Adds method registration
2021-03-23 09:31:12 +00:00
change name of the librarry
2021-03-25 00:59:41 +00:00
install(TARGETS pqc pqc_s
Adds method registration
2021-03-23 09:31:12 +00:00
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE WORLD_READ WORLD_WRITE
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib)
install(FILES
${QRS_PUBLIC_INC}
change name of the librarry
2021-03-25 00:59:41 +00:00
DESTINATION include/pqc)
Reference in New Issue Copy Permalink