arachne::pheidippides::anonymous_namespace{hardened_transport.cpp} Namespace Reference

Classes
struct	timeout_settings
struct	retry_settings
struct	admission_settings
struct	cache_settings
struct	configured_redirect_policy
struct	policy_settings
struct	parsed_url
struct	authentication_settings
class	admission_gate
class	admission_lease
struct	endpoint_configuration
struct	door_configuration
struct	cached_artifact
struct	flight_state

Typedefs
using	json = nlohmann::json

Enumerations
enum class	authentication_mode {   none , bearer_environment , header_environment , none ,   bearer_environment , header_environment }
enum class	authentication_mode {   none , bearer_environment , header_environment , none ,   bearer_environment , header_environment }

Functions
std::string	ascii_lower (std::string value)
bool	safe_token (const std::string_view value)
bool	safe_environment_name (const std::string_view value)
bool	safe_http_header_name (const std::string_view value)
bool	safe_header_value (const std::string_view value, const std::size_t maximum_bytes)
void	reject_unknown_keys (const json &object, const std::span< const std::string_view > allowed, const std::string_view location)
const json &	required_object (const json &object, const std::string_view key, const std::string_view location)
std::string	required_string (const json &object, const std::string_view key, const std::string_view location)
std::uint64_t	bounded_unsigned (const json &object, const std::string_view key, const std::uint64_t fallback, const std::uint64_t minimum, const std::uint64_t maximum, const std::string_view location)
bool	optional_boolean (const json &object, const std::string_view key, const bool fallback, const std::string_view location)
void	apply_settings (policy_settings &policy, const json &object, const std::string_view location)
std::string	curl_url_part (CURLU *url, const CURLUPart part)
parsed_url	parse_absolute_url (const std::string &value, const std::string_view location)
bool	within_base_url (const parsed_url &request, const parsed_url &base)
std::string	configured_authority (const parsed_url &url)
authentication_settings	parse_authentication (const json &object, const std::string_view location)
acquired_artifact_v1	policy_failure (const fetch_request_v1 &request, const transport_status status, std::string message)
bool	sensitive_header (const std::string_view name)
std::string	request_cache_key (const fetch_request_v1 &request)
bool	safe_cached_file (const fs::path &root, const std::string &storage_ref, const std::string &expected_sha256, const std::uint64_t expected_size)
std::optional< cached_artifact >	read_cache_entry (const fs::path &root, const fs::path &cache_root, const std::string &cache_key)
void	write_cache_entry (const fs::path &cache_root, const std::string &cache_key, const acquired_artifact_v1 &acquired)
acquired_artifact_v1	cached_receipt (const fetch_request_v1 &request, const cached_artifact &cached, const delivery_mode mode)

Variables
constexpr std::uint64_t	maximum_policy_milliseconds = 86'400'000U
constexpr std::uint64_t	maximum_cache_seconds = 31'536'000U
constexpr std::uint64_t	maximum_cache_document_bytes = 64U * 1024U
std::atomic< std::uint64_t >	cache_stage_sequence { 0 }

Typedef Documentation

json

using arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::json = nlohmann::json

Definition at line 36 of file hardened_transport.cpp.

Enumeration Type Documentation

authentication_mode [1/2]

enum class arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::authentication_mode

strong

Enumerator
none
bearer_environment
header_environment
none
bearer_environment
header_environment

Definition at line 537 of file hardened_transport.cpp.

                                   {
        none,
        bearer_environment,
        header_environment
    };

authentication_mode [2/2]

enum class arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::authentication_mode

strong

Enumerator
none
bearer_environment
header_environment
none
bearer_environment
header_environment

Definition at line 537 of file hardened_transport.cpp.

                                   {
        none,
        bearer_environment,
        header_environment
    };

Function Documentation

apply_settings()

void arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::apply_settings	(	policy_settings &	policy,
		const json &	object,
		const std::string_view	location )

Definition at line 237 of file hardened_transport.cpp.

      {
        constexpr std::array allowed {
            std::string_view { "timeouts" },
            std::string_view { "retry" },
            std::string_view { "admission" },
            std::string_view { "cache" },
            std::string_view { "redirect_policy" },
            std::string_view { "maximum_artifact_bytes" },
        };
        reject_unknown_keys(object, allowed, location);
 
        if (const auto value = object.find("timeouts"); value != object.end()) {
            constexpr std::array fields {
                std::string_view { "total_ms" },
                std::string_view { "connect_ms" },
                std::string_view { "read_ms" },
                std::string_view { "write_ms" },
                std::string_view { "pool_ms" },
            };
            reject_unknown_keys(
                *value, fields, std::string(location) + ".timeouts"
            );
            policy.timeouts.total = std::chrono::milliseconds(bounded_unsigned(
                *value, "total_ms",
                static_cast<std::uint64_t>(policy.timeouts.total.count()), 1U,
                maximum_policy_milliseconds, std::string(location) + ".timeouts"
            ));
            policy.timeouts.connect
                = std::chrono::milliseconds(bounded_unsigned(
                    *value, "connect_ms",
                    static_cast<std::uint64_t>(policy.timeouts.connect.count()),
                    1U, maximum_policy_milliseconds,
                    std::string(location) + ".timeouts"
                ));
            policy.timeouts.read = std::chrono::milliseconds(bounded_unsigned(
                *value, "read_ms",
                static_cast<std::uint64_t>(policy.timeouts.read.count()), 1U,
                maximum_policy_milliseconds, std::string(location) + ".timeouts"
            ));
            policy.timeouts.write = std::chrono::milliseconds(bounded_unsigned(
                *value, "write_ms",
                static_cast<std::uint64_t>(policy.timeouts.write.count()), 1U,
                maximum_policy_milliseconds, std::string(location) + ".timeouts"
            ));
            policy.timeouts.pool = std::chrono::milliseconds(bounded_unsigned(
                *value, "pool_ms",
                static_cast<std::uint64_t>(policy.timeouts.pool.count()), 1U,
                maximum_policy_milliseconds, std::string(location) + ".timeouts"
            ));
        }
        if (const auto value = object.find("retry"); value != object.end()) {
            constexpr std::array fields {
                std::string_view { "maximum_attempts" },
                std::string_view { "initial_delay_ms" },
                std::string_view { "maximum_delay_ms" },
                std::string_view { "total_delay_budget_ms" },
                std::string_view { "respect_retry_after" },
            };
            reject_unknown_keys(
                *value, fields, std::string(location) + ".retry"
            );
            policy.retry.maximum_attempts
                = static_cast<std::size_t>(bounded_unsigned(
                    *value, "maximum_attempts", policy.retry.maximum_attempts,
                    1U, 20U, std::string(location) + ".retry"
                ));
            policy.retry
                .initial_delay = std::chrono::milliseconds(bounded_unsigned(
                *value, "initial_delay_ms",
                static_cast<std::uint64_t>(policy.retry.initial_delay.count()),
                0U, maximum_policy_milliseconds,
                std::string(location) + ".retry"
            ));
            policy.retry
                .maximum_delay = std::chrono::milliseconds(bounded_unsigned(
                *value, "maximum_delay_ms",
                static_cast<std::uint64_t>(policy.retry.maximum_delay.count()),
                0U, maximum_policy_milliseconds,
                std::string(location) + ".retry"
            ));
            policy.retry.total_delay_budget
                = std::chrono::milliseconds(bounded_unsigned(
                    *value, "total_delay_budget_ms",
                    static_cast<std::uint64_t>(
                        policy.retry.total_delay_budget.count()
                    ),
                    0U, maximum_policy_milliseconds,
                    std::string(location) + ".retry"
                ));
            policy.retry.respect_retry_after = optional_boolean(
                *value, "respect_retry_after", policy.retry.respect_retry_after,
                std::string(location) + ".retry"
            );
        }
        if (const auto value = object.find("admission");
            value != object.end()) {
            constexpr std::array fields {
                std::string_view { "maximum_concurrency" },
                std::string_view { "minimum_interval_ms" },
            };
            reject_unknown_keys(
                *value, fields, std::string(location) + ".admission"
            );
            policy.admission.maximum_concurrency
                = static_cast<std::size_t>(bounded_unsigned(
                    *value, "maximum_concurrency",
                    policy.admission.maximum_concurrency, 1U, 1'024U,
                    std::string(location) + ".admission"
                ));
            policy.admission.minimum_interval
                = std::chrono::milliseconds(bounded_unsigned(
                    *value, "minimum_interval_ms",
                    static_cast<std::uint64_t>(
                        policy.admission.minimum_interval.count()
                    ),
                    0U, maximum_policy_milliseconds,
                    std::string(location) + ".admission"
                ));
        }
        if (const auto value = object.find("cache"); value != object.end()) {
            constexpr std::array fields { std::string_view { "ttl_seconds" } };
            reject_unknown_keys(
                *value, fields, std::string(location) + ".cache"
            );
            policy.cache.ttl = std::chrono::seconds(bounded_unsigned(
                *value, "ttl_seconds",
                static_cast<std::uint64_t>(policy.cache.ttl.count()), 0U,
                maximum_cache_seconds, std::string(location) + ".cache"
            ));
        }
        if (const auto value = object.find("redirect_policy");
            value != object.end()) {
            constexpr std::array fields {
                std::string_view { "follow" },
                std::string_view { "maximum_redirects" },
                std::string_view { "allow_https_to_http" },
                std::string_view { "allowed_hosts" },
            };
            reject_unknown_keys(
                *value, fields, std::string(location) + ".redirect_policy"
            );
            policy.redirects.follow = optional_boolean(
                *value, "follow", policy.redirects.follow,
                std::string(location) + ".redirect_policy"
            );
            policy.redirects.maximum_redirects
                = static_cast<std::size_t>(bounded_unsigned(
                    *value, "maximum_redirects",
                    policy.redirects.maximum_redirects, 0U, 20U,
                    std::string(location) + ".redirect_policy"
                ));
            policy.redirects.allow_https_to_http = optional_boolean(
                *value, "allow_https_to_http",
                policy.redirects.allow_https_to_http,
                std::string(location) + ".redirect_policy"
            );
            if (const auto hosts = value->find("allowed_hosts");
                hosts != value->end()) {
                if (!hosts->is_array() || hosts->empty()) {
                    throw std::invalid_argument(
                        std::string(location)
                        + ".redirect_policy.allowed_hosts must be a non-empty "
                          "array"
                    );
                }
                policy.redirects.allowed_hosts.clear();
                for (const auto& host : *hosts) {
                    if (!host.is_string()
                        || host.get_ref<const std::string&>().empty()) {
                        throw std::invalid_argument(
                            std::string(location)
                            + ".redirect_policy.allowed_hosts contains an "
                              "invalid host"
                        );
                    }
                    policy.redirects.allowed_hosts.push_back(
                        host.get<std::string>()
                    );
                }
            }
        }
        policy.maximum_artifact_bytes = bounded_unsigned(
            object, "maximum_artifact_bytes", policy.maximum_artifact_bytes, 1U,
            static_cast<std::uint64_t>(
                std::numeric_limits<std::int64_t>::max()
            ),
            location
        );
 
        if (policy.timeouts.connect > policy.timeouts.total) {
            throw std::invalid_argument(
                std::string(location) + " connect timeout exceeds total timeout"
            );
        }
        if (policy.retry.initial_delay > policy.retry.maximum_delay) {
            throw std::invalid_argument(
                std::string(location)
                + " initial retry delay exceeds maximum retry delay"
            );
        }
        if (!policy.redirects.follow
            && policy.redirects.maximum_redirects != 0U) {
            throw std::invalid_argument(
                std::string(location)
                + " disables redirects but permits redirect attempts"
            );
        }
    }

ascii_lower()

std::string arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::ascii_lower ( std::string value )

nodiscard

Definition at line 44 of file hardened_transport.cpp.

                                                         {
        std::ranges::transform(value, value.begin(), [](const char character) {
            return static_cast<char>(
                std::tolower(static_cast<unsigned char>(character))
            );
        });
        return value;
    }

Referenced by arachne::pheidippides::hardened_transport::implementation::implementation(), parse_authentication(), and sensitive_header().

Here is the caller graph for this function:

bounded_unsigned()

std::uint64_t arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::bounded_unsigned ( const json & object, const std::string_view key, const std::uint64_t fallback, const std::uint64_t minimum, const std::uint64_t maximum, const std::string_view location )

nodiscard

Definition at line 146 of file hardened_transport.cpp.

      {
        const auto value = object.find(key);
        if (value == object.end()) {
            return fallback;
        }
        if (!value->is_number_unsigned() && !value->is_number_integer()) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " must be an integer"
            );
        }
        std::uint64_t result = 0;
        try {
            result = value->get<std::uint64_t>();
        } catch (const json::exception&) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " must be non-negative"
            );
        }
        if (result < minimum || result > maximum) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " is outside the supported range"
            );
        }
        return result;
    }

cached_receipt()

acquired_artifact_v1 arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_receipt ( const fetch_request_v1 & request, const cached_artifact & cached, const delivery_mode mode )

nodiscard

Definition at line 912 of file hardened_transport.cpp.

      {
        const auto now = std::chrono::system_clock::now();
        acquired_artifact_v1 result;
        result.artifact_id = "artifact-" + request.request_id;
        result.request_id = request.request_id;
        result.door_id = request.door_id;
        result.operation = request.operation;
        result.delivered_via = mode;
        result.status = transport_status::delivered;
        result.source_url = request.url;
        result.effective_url = request.url;
        result.http_status = cached.http_status;
        result.artifact_ref = cached.artifact_ref;
        result.sha256 = cached.sha256;
        result.byte_count = cached.byte_count;
        result.started_at = now;
        result.completed_at = now;
        return result;
    }

References arachne::pheidippides::acquired_artifact_v1::artifact_id, arachne::pheidippides::acquired_artifact_v1::artifact_ref, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::artifact_ref, arachne::pheidippides::acquired_artifact_v1::byte_count, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::byte_count, arachne::pheidippides::delivered, arachne::pheidippides::acquired_artifact_v1::delivered_via, arachne::pheidippides::acquired_artifact_v1::door_id, arachne::pheidippides::fetch_request_v1::door_id, arachne::pheidippides::acquired_artifact_v1::effective_url, arachne::pheidippides::acquired_artifact_v1::http_status, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::http_status, arachne::pheidippides::acquired_artifact_v1::operation, arachne::pheidippides::fetch_request_v1::operation, arachne::pheidippides::acquired_artifact_v1::request_id, arachne::pheidippides::fetch_request_v1::request_id, arachne::pheidippides::acquired_artifact_v1::sha256, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::sha256, arachne::pheidippides::acquired_artifact_v1::source_url, arachne::pheidippides::acquired_artifact_v1::status, and arachne::pheidippides::fetch_request_v1::url.

configured_authority()

std::string arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::configured_authority ( const parsed_url & url )

nodiscard

Definition at line 641 of file hardened_transport.cpp.

                                                                        {
        const bool default_port = (url.scheme == "https" && url.port == 443U)
            || (url.scheme == "http" && url.port == 80U);
        return url.host
            + (default_port ? std::string {} : ":" + std::to_string(url.port));
    }

References arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::host, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::port, and arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::scheme.

Referenced by arachne::pheidippides::hardened_transport::implementation::implementation().

Here is the caller graph for this function:

curl_url_part()

std::string arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::curl_url_part ( CURLU * url, const CURLUPart part )

nodiscard

Definition at line 457 of file hardened_transport.cpp.

                                                                            {
        char* raw = nullptr;
        const CURLUcode status = curl_url_get(url, part, &raw, 0);
        if (status != CURLUE_OK || raw == nullptr) {
            return {};
        }
        std::unique_ptr<char, decltype(&curl_free)> owned(raw, &curl_free);
        return std::string(raw);
    }

optional_boolean()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::optional_boolean ( const json & object, const std::string_view key, const bool fallback, const std::string_view location )

nodiscard

Definition at line 179 of file hardened_transport.cpp.

      {
        const auto value = object.find(key);
        if (value == object.end()) {
            return fallback;
        }
        if (!value->is_boolean()) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " must be boolean"
            );
        }
        return value->get<bool>();
    }

parse_absolute_url()

parsed_url arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parse_absolute_url ( const std::string & value, const std::string_view location )

nodiscard

Definition at line 467 of file hardened_transport.cpp.

      {
        std::unique_ptr<CURLU, decltype(&curl_url_cleanup)> url(
            curl_url(), &curl_url_cleanup
        );
        if (!url
            || curl_url_set(url.get(), CURLUPART_URL, value.c_str(), 0)
                != CURLUE_OK) {
            throw std::invalid_argument(
                std::string(location) + " is not an absolute URL"
            );
        }
        parsed_url result;
        result.scheme = ascii_lower(curl_url_part(url.get(), CURLUPART_SCHEME));
        result.host = ascii_lower(curl_url_part(url.get(), CURLUPART_HOST));
        result.path = curl_url_part(url.get(), CURLUPART_PATH);
        result.normalized = curl_url_part(url.get(), CURLUPART_URL);
        const std::string port = curl_url_part(url.get(), CURLUPART_PORT);
        if (result.scheme != "http" && result.scheme != "https") {
            throw std::invalid_argument(
                std::string(location) + " must use HTTP or HTTPS"
            );
        }
        if (result.host.empty() || result.normalized.empty()
            || !curl_url_part(url.get(), CURLUPART_USER).empty()
            || !curl_url_part(url.get(), CURLUPART_PASSWORD).empty()
            || !curl_url_part(url.get(), CURLUPART_FRAGMENT).empty()) {
            throw std::invalid_argument(
                std::string(location) + " contains an unsafe URL authority"
            );
        }
        if (port.empty()) {
            result.port = result.scheme == "https" ? 443U : 80U;
        } else {
            try {
                const unsigned long converted = std::stoul(port);
                if (converted == 0UL || converted > 65'535UL) {
                    throw std::out_of_range("port");
                }
                result.port = static_cast<unsigned>(converted);
            } catch (const std::exception&) {
                throw std::invalid_argument(
                    std::string(location) + " has an invalid port"
                );
            }
        }
        if (result.path.empty()) {
            result.path = "/";
        }
        return result;
    }

References arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::host, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::normalized, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::path, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::port, and arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::scheme.

parse_authentication()

authentication_settings arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parse_authentication ( const json & object, const std::string_view location )

nodiscard

Definition at line 649 of file hardened_transport.cpp.

                                                                            {
        constexpr std::array fields {
            std::string_view { "mode" },
            std::string_view { "secret_name" },
            std::string_view { "header_name" },
        };
        reject_unknown_keys(object, fields, location);
        authentication_settings result;
        const std::string mode = required_string(object, "mode", location);
        if (mode == "none") {
            if (object.size() != 1U) {
                throw std::invalid_argument(
                    std::string(location)
                    + " mode none cannot declare secret fields"
                );
            }
            return result;
        }
        result.secret_name = required_string(object, "secret_name", location);
        if (!safe_environment_name(result.secret_name)) {
            throw std::invalid_argument(
                std::string(location)
                + ".secret_name is not an environment name"
            );
        }
        if (mode == "bearer_env") {
            result.mode = authentication_mode::bearer_environment;
            result.header_name = "Authorization";
            if (object.contains("header_name")) {
                throw std::invalid_argument(
                    std::string(location)
                    + " bearer_env cannot override its header"
                );
            }
            return result;
        }
        if (mode == "header_env") {
            result.mode = authentication_mode::header_environment;
            result.header_name
                = required_string(object, "header_name", location);
            const std::string lowered = ascii_lower(result.header_name);
            if (lowered == "host"
                || !safe_http_header_name(result.header_name)) {
                throw std::invalid_argument(
                    std::string(location) + ".header_name is unsafe"
                );
            }
            return result;
        }
        throw std::invalid_argument(
            std::string(location) + ".mode is unsupported"
        );
    }

References ascii_lower(), bearer_environment, header_environment, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::authentication_settings::header_name, and arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::authentication_settings::mode.

Here is the call graph for this function:

policy_failure()

acquired_artifact_v1 arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::policy_failure ( const fetch_request_v1 & request, const transport_status status, std::string message )

nodiscard

Definition at line 703 of file hardened_transport.cpp.

      {
        const auto now = std::chrono::system_clock::now();
        acquired_artifact_v1 result;
        result.artifact_id = "artifact-" + request.request_id;
        result.request_id = request.request_id;
        result.door_id = request.door_id;
        result.operation = request.operation;
        result.status = status;
        result.source_url = request.url;
        result.effective_url = request.url;
        result.started_at = now;
        result.completed_at = now;
        result.error_message = std::move(message);
        return result;
    }

References arachne::pheidippides::acquired_artifact_v1::artifact_id, arachne::pheidippides::acquired_artifact_v1::door_id, arachne::pheidippides::fetch_request_v1::door_id, arachne::pheidippides::acquired_artifact_v1::effective_url, arachne::pheidippides::acquired_artifact_v1::error_message, arachne::pheidippides::acquired_artifact_v1::operation, arachne::pheidippides::fetch_request_v1::operation, arachne::pheidippides::acquired_artifact_v1::request_id, arachne::pheidippides::fetch_request_v1::request_id, arachne::pheidippides::acquired_artifact_v1::source_url, arachne::pheidippides::acquired_artifact_v1::status, and arachne::pheidippides::fetch_request_v1::url.

read_cache_entry()

std::optional< cached_artifact > arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::read_cache_entry ( const fs::path & root, const fs::path & cache_root, const std::string & cache_key )

nodiscard

Definition at line 806 of file hardened_transport.cpp.

      {
        const fs::path path = cache_root / (cache_key + ".json");
        std::error_code error;
        const auto state = fs::symlink_status(path, error);
        if (error || fs::is_symlink(state) || !fs::is_regular_file(state)) {
            return std::nullopt;
        }
        const auto size = fs::file_size(path, error);
        if (error || size > maximum_cache_document_bytes) {
            return std::nullopt;
        }
        try {
            std::ifstream input(path, std::ios::binary);
            const json document = json::parse(input);
            if (!document.is_object() || document.value("cache_version", 0) != 1
                || document.value("cache_key", std::string {}) != cache_key) {
                return std::nullopt;
            }
            cached_artifact result {
                .artifact_ref = document.at("artifact_ref").get<std::string>(),
                .sha256 = document.at("sha256").get<std::string>(),
                .byte_count = document.at("byte_count").get<std::uint64_t>(),
                .http_status = document.at("http_status").get<long>(),
                .stored_unix = document.at("stored_unix").get<std::int64_t>(),
            };
            if (!safe_cached_file(
                    root, result.artifact_ref, result.sha256, result.byte_count
                )) {
                return std::nullopt;
            }
            return result;
        } catch (const std::exception&) {
            return std::nullopt;
        }
    }

References arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::artifact_ref, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::byte_count, maximum_cache_document_bytes, safe_cached_file(), and arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cached_artifact::sha256.

Here is the call graph for this function:

reject_unknown_keys()

void arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::reject_unknown_keys	(	const json &	object,
		const std::span< const std::string_view >	allowed,
		const std::string_view	location )

Definition at line 98 of file hardened_transport.cpp.

      {
        if (!object.is_object()) {
            throw std::invalid_argument(
                std::string(location) + " must be an object"
            );
        }
        for (const auto& [key, unused] : object.items()) {
            static_cast<void>(unused);
            if (std::ranges::find(allowed, key) == allowed.end()) {
                throw std::invalid_argument(
                    std::string(location) + " contains unknown field " + key
                );
            }
        }
    }

request_cache_key()

std::string arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::request_cache_key ( const fetch_request_v1 & request )

nodiscard

Definition at line 732 of file hardened_transport.cpp.

                                                       {
        std::vector<std::pair<std::string, std::string>> headers;
        headers.reserve(request.headers.size());
        for (const auto& header : request.headers) {
            const std::string name = ascii_lower(header.name);
            const std::string value = sensitive_header(name)
                ? "sha256:" + crypto::sha256(header.value)
                : header.value;
            headers.emplace_back(name, value);
        }
        std::ranges::sort(headers);
        nlohmann::ordered_json identity {
            { "door_id", request.door_id },
            { "endpoint_id", request.endpoint_id },
            { "operation", to_string(request.operation) },
            { "method", request.method == http_method::get ? "GET" : "POST" },
            { "url", request.url },
            { "headers", nlohmann::ordered_json::array() },
            { "body_sha256",
              request.body_artifact ? request.body_artifact->sha256
                                    : crypto::sha256(request.body) },
            { "resume_sha256",
              request.resume_artifact ? request.resume_artifact->sha256
                                      : std::string {} },
            { "expected_sha256",
              request.expected_sha256.value_or(std::string {}) },
            { "maximum_bytes", request.max_bytes },
        };
        for (const auto& [name, value] : headers) {
            identity["headers"].push_back(
                { { "name", name }, { "value", value } }
            );
        }
        return crypto::sha256(
            arachnespace::contracts::canonical_json(identity)
        );
    }

References arachne::crypto::sha256().

Referenced by arachne::pheidippides::hardened_transport::implementation::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

required_object()

const json & arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::required_object ( const json & object, const std::string_view key, const std::string_view location )

nodiscard

Definition at line 117 of file hardened_transport.cpp.

      {
        const auto value = object.find(key);
        if (value == object.end() || !value->is_object()) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " must be an object"
            );
        }
        return *value;
    }

required_string()

std::string arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::required_string ( const json & object, const std::string_view key, const std::string_view location )

nodiscard

Definition at line 131 of file hardened_transport.cpp.

      {
        const auto value = object.find(key);
        if (value == object.end() || !value->is_string()
            || value->get_ref<const std::string&>().empty()) {
            throw std::invalid_argument(
                std::string(location) + "." + std::string(key)
                + " must be a non-empty string"
            );
        }
        return value->get<std::string>();
    }

safe_cached_file()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::safe_cached_file ( const fs::path & root, const std::string & storage_ref, const std::string & expected_sha256, const std::uint64_t expected_size )

nodiscard

Definition at line 778 of file hardened_transport.cpp.

      {
        if (!crypto::is_safe_relative_artifact_ref(storage_ref)) {
            return false;
        }
        fs::path current = root;
        for (const auto& component : fs::path(storage_ref)) {
            current /= component;
            std::error_code error;
            const auto state = fs::symlink_status(current, error);
            if (error || fs::is_symlink(state)) {
                return false;
            }
        }
        std::error_code error;
        if (!fs::is_regular_file(current)
            || fs::file_size(current, error) != expected_size || error) {
            return false;
        }
        try {
            return crypto::sha256_file(current) == expected_sha256;
        } catch (const std::exception&) {
            return false;
        }
    }

References arachne::crypto::sha256_file().

Referenced by read_cache_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_environment_name()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::safe_environment_name ( const std::string_view value )

nodiscard

Definition at line 64 of file hardened_transport.cpp.

                                                                         {
        if (value.empty()
            || (std::isalpha(static_cast<unsigned char>(value.front())) == 0
                && value.front() != '_')) {
            return false;
        }
        return std::ranges::all_of(value.substr(1), [](const char character) {
            return std::isalnum(static_cast<unsigned char>(character)) != 0
                || character == '_';
        });
    }

safe_header_value()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::safe_header_value ( const std::string_view value, const std::size_t maximum_bytes )

nodiscard

Definition at line 88 of file hardened_transport.cpp.

      {
        return !value.empty() && value.size() <= maximum_bytes
            && std::ranges::none_of(value, [](const char character) {
                   return character == '\0' || character == '\r'
                       || character == '\n';
               });
    }

safe_http_header_name()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::safe_http_header_name ( const std::string_view value )

nodiscard

Definition at line 76 of file hardened_transport.cpp.

                                                                         {
        if (value.empty()) {
            return false;
        }
        constexpr std::string_view separators = "()<>@,;:\\\"/[]?={} \t";
        return std::ranges::none_of(value, [&](const char character) {
            const auto byte = static_cast<unsigned char>(character);
            return byte < 0x20U || byte == 0x7fU
                || separators.find(character) != std::string_view::npos;
        });
    }

safe_token()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::safe_token ( const std::string_view value )

nodiscard

Definition at line 53 of file hardened_transport.cpp.

                                                              {
        if (value.empty()
            || std::isalnum(static_cast<unsigned char>(value.front())) == 0) {
            return false;
        }
        return std::ranges::all_of(value.substr(1), [](const char character) {
            return std::isalnum(static_cast<unsigned char>(character)) != 0
                || character == '.' || character == '_' || character == '-';
        });
    }

sensitive_header()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::sensitive_header ( const std::string_view name )

nodiscard

Definition at line 722 of file hardened_transport.cpp.

                                                                   {
        const std::string lowered = ascii_lower(std::string(name));
        return lowered == "authorization" || lowered == "proxy-authorization"
            || lowered == "cookie" || lowered == "set-cookie"
            || lowered == "x-api-key" || lowered == "api-key"
            || lowered == "x-goog-api-key" || lowered == "x-auth-token"
            || lowered == "x-access-token" || lowered == "private-token";
    }

References ascii_lower().

Here is the call graph for this function:

within_base_url()

bool arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::within_base_url ( const parsed_url & request, const parsed_url & base )

nodiscard

Definition at line 521 of file hardened_transport.cpp.

                                                                       {
        if (request.scheme != base.scheme || request.host != base.host
            || request.port != base.port) {
            return false;
        }
        if (base.path == "/") {
            return true;
        }
        if (!request.path.starts_with(base.path)) {
            return false;
        }
        return base.path.ends_with('/')
            || request.path.size() == base.path.size()
            || request.path.at(base.path.size()) == '/';
    }

References arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::host, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::path, arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::port, and arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::parsed_url::scheme.

Referenced by arachne::pheidippides::hardened_transport::implementation::execute().

Here is the caller graph for this function:

write_cache_entry()

void arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::write_cache_entry	(	const fs::path &	cache_root,
		const std::string &	cache_key,
		const acquired_artifact_v1 &	acquired )

Definition at line 845 of file hardened_transport.cpp.

      {
        const auto stored_unix
            = std::chrono::duration_cast<std::chrono::seconds>(
                  std::chrono::system_clock::now().time_since_epoch()
            )
                  .count();
        const nlohmann::ordered_json document {
            { "cache_version", 1 },
            { "cache_key", cache_key },
            { "stored_unix", stored_unix },
            { "artifact_ref", acquired.artifact_ref },
            { "sha256", acquired.sha256 },
            { "byte_count", acquired.byte_count },
            { "http_status", acquired.http_status },
        };
        const std::string bytes
            = arachnespace::contracts::canonical_json(document) + "\n";
        const auto sequence
            = cache_stage_sequence.fetch_add(1U, std::memory_order_relaxed);
        const fs::path temporary = cache_root
            / (".stage-" + std::to_string(::getpid()) + "-"
               + std::to_string(sequence));
        const fs::path target = cache_root / (cache_key + ".json");
        const int descriptor = ::open(
            temporary.c_str(),
            O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW, 0600
        );
        if (descriptor < 0) {
            return;
        }
        std::size_t offset = 0;
        bool written = true;
        while (offset < bytes.size()) {
            const ssize_t count = ::write(
                descriptor, bytes.data() + offset, bytes.size() - offset
            );
            if (count < 0 && errno == EINTR) {
                continue;
            }
            if (count <= 0) {
                written = false;
                break;
            }
            offset += static_cast<std::size_t>(count);
        }
        if (written && ::fsync(descriptor) != 0) {
            written = false;
        }
        if (::close(descriptor) != 0) {
            written = false;
        }
        if (!written) {
            std::error_code ignored;
            fs::remove(temporary, ignored);
            return;
        }
        std::error_code error;
        fs::rename(temporary, target, error);
        if (error) {
            std::error_code ignored;
            fs::remove(temporary, ignored);
        }
    }

References arachne::pheidippides::acquired_artifact_v1::artifact_ref, arachne::pheidippides::acquired_artifact_v1::byte_count, cache_stage_sequence, arachne::pheidippides::acquired_artifact_v1::http_status, and arachne::pheidippides::acquired_artifact_v1::sha256.

Variable Documentation

cache_stage_sequence

std::atomic< std::uint64_t > arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::cache_stage_sequence { 0 }

Definition at line 42 of file hardened_transport.cpp.

{ 0 };

Referenced by write_cache_entry().

maximum_cache_document_bytes

std::uint64_t arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::maximum_cache_document_bytes = 64U * 1024U

constexpr

Definition at line 41 of file hardened_transport.cpp.

Referenced by read_cache_entry().

maximum_cache_seconds

std::uint64_t arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::maximum_cache_seconds = 31'536'000U

constexpr

Definition at line 40 of file hardened_transport.cpp.

maximum_policy_milliseconds

std::uint64_t arachne::pheidippides::anonymous_namespace{hardened_transport.cpp}::maximum_policy_milliseconds = 86'400'000U

constexpr

Definition at line 39 of file hardened_transport.cpp.