secret.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Judica, Inc.
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit/.
 
#pragma once
 
#include <cstddef>
#include <memory>
#include <string_view>
#include <type_traits>
#include <utility>
 
#include "purify/curve.hpp"
 
namespace purify::detail {
 
inline void secure_clear_bytes(void* data, std::size_t size) noexcept {
    volatile unsigned char* out = reinterpret_cast<volatile unsigned char*>(data);
    while (size != 0) {
        *out = 0;
        ++out;
        --size;
    }
}
 
struct SecureUInt512Deleter {
    void operator()(UInt512* value) const noexcept {
        if (value == nullptr) {
            return;
        }
        static_assert(std::is_trivially_destructible_v<UInt512>);
        secure_clear_bytes(value, sizeof(UInt512));
        delete value;
    }
};
 
}  // namespace purify::detail
 
namespace purify {
 
class SecretKey {
public:
    SecretKey() = delete;
    SecretKey(const SecretKey&) = delete;
    SecretKey& operator=(const SecretKey&) = delete;
    SecretKey(SecretKey&&) noexcept = default;
    SecretKey& operator=(SecretKey&&) noexcept = default;
    ~SecretKey() = default;
 
    [[nodiscard]] static Result<SecretKey> from_packed(const UInt512& packed) {
        PURIFY_RETURN_IF_ERROR(validate_secret_key(packed), "SecretKey::from_packed:validate_secret_key");
        return SecretKey(std::unique_ptr<UInt512, detail::SecureUInt512Deleter>(new UInt512(packed)));
    }
 
    [[nodiscard]] static Result<SecretKey> from_hex(std::string_view hex) {
        PURIFY_ASSIGN_OR_RETURN(const auto& packed, UInt512::try_from_hex(hex), "SecretKey::from_hex:try_from_hex");
        return from_packed(packed);
    }
 
    [[nodiscard]] Result<SecretKey> clone() const {
        return from_packed(packed());
    }
 
    [[nodiscard]] const UInt512& packed() const noexcept {
        return *packed_;
    }
 
    [[nodiscard]] bool operator==(const SecretKey& other) const noexcept {
        return packed() == other.packed();
    }
 
private:
    explicit SecretKey(std::unique_ptr<UInt512, detail::SecureUInt512Deleter>&& packed) noexcept
        : packed_(std::move(packed)) {}
 
    std::unique_ptr<UInt512, detail::SecureUInt512Deleter> packed_;
};
 
}  // namespace purify