OpenSSF gold badge: hardening

CMakeLists.txt

@@ -12,6 +12,7 @@ include("cmake/pgm_version.cmake")
 project(power_grid_model VERSION ${PGM_VERSION})
 
 option(PGM_ENABLE_DEV_BUILD "Enable developer build (e.g.: tests)" OFF)
+option(PGM_ENABLE_HARDENING "Enable compile and link time hardening options" ON)
 
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

CMakePresets.json

@@ -109,7 +109,7 @@
     {
       "name": "unix-sanitizer",
       "environment": {
-        "SANITIZER_FLAGS": "-fsanitize=address"
+        "SANITIZER_FLAGS": "-fstack-protector -fsanitize=address,pointer-compare,undefined"
       },
       "inherits": "unix-base",
       "hidden": true
@@ -137,6 +137,9 @@
     {
       "name": "msvc-debug",
       "displayName": "Debug (MSVC)",
+      "environment": {
+        "SANITIZER_FLAGS": "/RTC1"
+      },
       "inherits": [
         "msvc-base",
         "debug"

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -97,14 +97,14 @@ class ColumnarAttributeRange : public std::ranges::view_interface<ColumnarAttrib
             for (auto const& attribute_buffer : attribute_buffers_) {
                 assert(attribute_buffer.meta_attribute != nullptr);
                 auto const& meta_attribute = *attribute_buffer.meta_attribute;
-                ctype_func_selector(
-                    meta_attribute.ctype, [&result, &attribute_buffer, &meta_attribute, this]<typename AttributeType> {
-                        AttributeType const* buffer_ptr =
-                            reinterpret_cast<AttributeType const*>(attribute_buffer.data) + idx_;
-                        auto& attribute_ref =
-                            meta_attribute.template get_attribute<AttributeType>(reinterpret_cast<RawDataPtr>(&result));
-                        attribute_ref = *buffer_ptr;
-                    });
+                ctype_func_selector(meta_attribute.ctype, [&result, &attribute_buffer, &meta_attribute,
+                                                           idx = idx_]<typename AttributeType> {
+                    AttributeType const* buffer_ptr =
+                        reinterpret_cast<AttributeType const*>(attribute_buffer.data) + idx;
+                    AttributeType& attribute_ref =
+                        meta_attribute.template get_attribute<AttributeType>(reinterpret_cast<RawDataPtr>(&result));
+                    attribute_ref = *buffer_ptr;
+                });
             }
             return result;
         }

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp

@@ -289,6 +289,9 @@ template <symmetry_tag sym> class YBus {
          std::shared_ptr<MathModelParam<sym> const> const& param,
          std::shared_ptr<YBusStructure const> const& y_bus_struct = {})
         : math_topology_{topo_ptr} {
+        assert(math_topology_ != nullptr);
+        assert(param != nullptr);
+
         // use existing struct or make new struct
         if (y_bus_struct) {
             y_bus_struct_ = y_bus_struct;
@@ -447,36 +450,40 @@ template <symmetry_tag sym> class YBus {
     template <typename T>
         requires std::same_as<T, BranchSolverOutput<sym>> || std::same_as<T, BranchShortCircuitSolverOutput<sym>>
     std::vector<T> calculate_branch_flow(ComplexValueVector<sym> const& u) const {
-        std::vector<T> branch_flow(math_topology_->branch_bus_idx.size());
-        std::transform(math_topology_->branch_bus_idx.cbegin(), math_topology_->branch_bus_idx.cend(),
-                       math_model_param_->branch_param.cbegin(), branch_flow.begin(),
-                       [&u](BranchIdx branch_idx, BranchCalcParam<sym> const& param) {
-                           auto const [f, t] = branch_idx;
-                           // if one side is disconnected, use zero voltage at that side
-                           ComplexValue<sym> const uf = f != -1 ? u[f] : ComplexValue<sym>{0.0};
-                           ComplexValue<sym> const ut = t != -1 ? u[t] : ComplexValue<sym>{0.0};
-                           T output;
-
-                           // See "Branch Flow Calculation" in "State Estimation Alliander"
-                           output.i_f = dot(param.yff(), uf) + dot(param.yft(), ut);
-                           output.i_t = dot(param.ytf(), uf) + dot(param.ytt(), ut);
-
-                           if constexpr (std::same_as<T, BranchSolverOutput<sym>>) {
-                               // See "Shunt Injection Flow Calculation" in "State Estimation Alliander"
-                               output.s_f = uf * conj(output.i_f);
-                               output.s_t = ut * conj(output.i_t);
-                           }
-
-                           return output;
-                       });
-        return branch_flow;
+        assert(math_topology_ != nullptr);
+
+        return std::views::zip(math_topology_->branch_bus_idx, math_model_param_->branch_param) |
+               std::views::transform([&u](auto const& branch_idx_params) -> T {
+                   auto const& [branch_idx, param] = branch_idx_params;
+
+                   auto const [f, t] = branch_idx;
+                   // if one side is disconnected, use zero voltage at that side
+                   ComplexValue<sym> const uf = f != -1 ? u[f] : ComplexValue<sym>{0.0};
+                   ComplexValue<sym> const ut = t != -1 ? u[t] : ComplexValue<sym>{0.0};
+                   T output;
+
+                   // See "Branch Flow Calculation" in "State Estimation Alliander"
+                   output.i_f = dot(param.yff(), uf) + dot(param.yft(), ut);
+                   output.i_t = dot(param.ytf(), uf) + dot(param.ytt(), ut);
+
+                   if constexpr (std::same_as<T, BranchSolverOutput<sym>>) {
+                       // See "Shunt Injection Flow Calculation" in "State Estimation Alliander"
+                       output.s_f = uf * conj(output.i_f);
+                       output.s_t = ut * conj(output.i_t);
+                   }
+
+                   return output;
+               }) |
+               std::ranges::to<std::vector<T>>();
     }
 
     // calculate shunt flow based on voltage, injection direction
     template <typename SolverOutputType>
         requires std::same_as<SolverOutputType, ApplianceSolverOutput<sym>> ||
                  std::same_as<SolverOutputType, ApplianceShortCircuitSolverOutput<sym>>
     std::vector<SolverOutputType> calculate_shunt_flow(ComplexValueVector<sym> const& u) const {
+        assert(math_topology_ != nullptr);
+
         std::vector<SolverOutputType> shunt_flow(math_topology_->n_shunt());
         for (auto const [bus, shunts] : enumerated_zip_sequence(math_topology_->shunts_per_bus)) {
             for (Idx const shunt : shunts) {

power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp

@@ -356,7 +356,7 @@ class Topology {
         for (auto&& [idx, branch_node_idx, branch_connected] :
              std::views::zip(std::views::iota(0), std::as_const(comp_topo_.branch_node_idx),
                              std::as_const(comp_conn_.branch_connected))) {
-            assert(std::ssize(branch_connected) == 2); // NOSONAR(R354)
+            assert(std::ssize(branch_connected) == 2);
 
             auto const [i, j] = branch_node_idx;
             IntS const i_status = branch_connected[0];

power_grid_model_c/power_grid_model_c/CMakeLists.txt

@@ -49,6 +49,33 @@ set_target_properties(
         INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE
 )
 
+if(PGM_ENABLE_HARDENING)
+    target_compile_definitions(
+        power_grid_model_c
+        PRIVATE
+            "$<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:_FORTIFY_SOURCE=2>"
+            "$<$<CXX_COMPILER_ID:MSVC>:_ITERATOR_DEBUG_LEVEL=$<IF:$<CONFIG:DEBUG>,2,1>>"
+    )
+    if(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        set(_HAS_ADDRESS_SANITIZER
+            "$<NOT:$<OR:$<IN_LIST:address,${CMAKE_CFLAGS}>,$<IN_LIST:address,${CMAKE_CXXFLAGS}>>>"
+        )
+        target_compile_options(
+            power_grid_model_c
+            BEFORE
+            PRIVATE "-fstack-protector" "-fsanitize=undefined"
+        )
+    endif()
+    target_link_options(
+        power_grid_model_c
+        BEFORE
+        PRIVATE
+            "$<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-fstack-protector;-fsanitize=undefined>"
+            "$<$<CXX_COMPILER_ID:GNU>:-static-libubsan>"
+            "$<$<CXX_COMPILER_ID:Clang>:-lubsan>"
+    )
+endif()
+
 install(
     TARGETS power_grid_model_c
     EXPORT power_grid_modelTargets

tests/native_api_tests/CMakeLists.txt

@@ -31,4 +31,9 @@ target_compile_definitions(
     PRIVATE PGM_ENABLE_EXPERIMENTAL
 )
 
+set_target_properties(
+    power_grid_model_api_tests
+    PROPERTIES BUILD_RPATH $<TARGET_FILE_DIR:power_grid_model_c>
+)
+
 doctest_discover_tests(power_grid_model_api_tests)