memory_validator.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Jinwoo Sung
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "unilink/base/visibility.hpp"
 
namespace unilink {
namespace memory {
 
namespace memory_validator {
 
bool is_memory_accessible(const void* ptr, size_t size);
 
bool is_memory_aligned(const void* ptr, size_t alignment);
 
bool check_buffer_bounds(const void* ptr, size_t size, size_t canary_size = 8);
 
void initialize_canary_bytes(void* ptr, size_t size, size_t canary_size = 8);
 
bool validate_canary_bytes(const void* ptr, size_t size, size_t canary_size = 8);
 
void safe_memcpy_validated(void* dest, const void* src, size_t size);
 
void safe_memmove_validated(void* dest, const void* src, size_t size);
 
void safe_memset_validated(void* ptr, int value, size_t size);
 
bool is_double_free(void* ptr);
 
bool is_use_after_free(const void* ptr);
 
}  // namespace memory_validator
 
class UNILINK_API MemoryValidator {
 public:
  explicit MemoryValidator(void* ptr, size_t size, size_t canary_size = 8);
  ~MemoryValidator();
 
  // Non-copyable, non-movable
  MemoryValidator(const MemoryValidator&) = delete;
  MemoryValidator& operator=(const MemoryValidator&) = delete;
  MemoryValidator(MemoryValidator&&) = delete;
  MemoryValidator& operator=(MemoryValidator&&) = delete;
 
  // Validation methods
  bool validate() const;
  void check_bounds() const;
 
  // Access methods
  void* data() const { return ptr_; }
  size_t size() const { return size_; }
 
 private:
  void* ptr_;
  size_t size_;
  size_t canary_size_;
  std::vector<uint8_t> original_canaries_;
  bool canaries_initialized_;
 
  void initialize_canaries();
  bool validate_canaries() const;
};
 
class UNILINK_API MemoryPatternGenerator {
 public:
  static std::vector<uint8_t> generate_pattern(size_t size, uint8_t seed = 0xAA);
  static std::vector<uint8_t> generate_random_pattern(size_t size);
  static bool validate_pattern(const void* ptr, size_t size, uint8_t expected_seed = 0xAA);
};
 
}  // namespace memory
}  // namespace unilink