revocation.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/runtime/crypto.hpp>
 
#include <choc/text/choc_JSON.h>
 
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
namespace pulp::format::reload {
 
// ── SRL data model ──────────────────────────────────────────────────────────

struct SignedRevocationList {
    int schema_version = 1;
    std::uint64_t epoch = 0;                            
    std::string issued_utc;                             
    std::vector<std::string> revoked_signer_key_fprs;   
    std::vector<std::string> revoked_artifact_hashes;   
    std::vector<std::uint8_t> signer_public_key;        
    std::vector<std::uint8_t> signature;                
};
 
enum class SrlVerify {
    Ok = 0,
    ParseError,        
    UntrustedSigner,   
    BadSignature,      
};
 
struct SrlVerifyResult {
    SrlVerify status = SrlVerify::Ok;
    std::string detail;
    bool ok() const { return status == SrlVerify::Ok; }
};
 
// ── small helpers ────────────────────────────────────────────────────────────

inline std::string srl_to_lower(std::string s) {
    for (auto& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
    return s;
}

inline std::optional<std::vector<std::uint8_t>> srl_hex_decode(std::string_view hex) {
    if (hex.size() % 2 != 0) return std::nullopt;
    auto nibble = [](char c) -> int {
        if (c >= '0' && c <= '9') return c - '0';
        if (c >= 'a' && c <= 'f') return c - 'a' + 10;
        if (c >= 'A' && c <= 'F') return c - 'A' + 10;
        return -1;
    };
    std::vector<std::uint8_t> out;
    out.reserve(hex.size() / 2);
    for (std::size_t i = 0; i < hex.size(); i += 2) {
        const int hi = nibble(hex[i]), lo = nibble(hex[i + 1]);
        if (hi < 0 || lo < 0) return std::nullopt;
        out.push_back(static_cast<std::uint8_t>((hi << 4) | lo));
    }
    return out;
}

inline std::string srl_hex_encode(const std::vector<std::uint8_t>& bytes) {
    return runtime::hex_encode(bytes);
}
 
// ── canonical signed message ───────────────────────────────────────────────

inline std::vector<std::uint8_t> srl_signed_message(const SignedRevocationList& srl) {
    std::vector<std::uint8_t> out;
    auto put_u32 = [&out](std::uint32_t n) {
        out.push_back(static_cast<std::uint8_t>(n & 0xFF));
        out.push_back(static_cast<std::uint8_t>((n >> 8) & 0xFF));
        out.push_back(static_cast<std::uint8_t>((n >> 16) & 0xFF));
        out.push_back(static_cast<std::uint8_t>((n >> 24) & 0xFF));
    };
    auto put_u64 = [&out](std::uint64_t n) {
        for (int i = 0; i < 8; ++i) out.push_back(static_cast<std::uint8_t>((n >> (i * 8)) & 0xFF));
    };
    auto put_field = [&](std::string_view s) {
        put_u32(static_cast<std::uint32_t>(s.size()));
        out.insert(out.end(), s.begin(), s.end());
    };
    put_field("pulp-revocation-list-v1");
    put_u32(static_cast<std::uint32_t>(srl.schema_version));
    put_u64(srl.epoch);
    put_field(srl.issued_utc);
    put_u32(static_cast<std::uint32_t>(srl.revoked_signer_key_fprs.size()));
    for (const auto& fpr : srl.revoked_signer_key_fprs) put_field(srl_to_lower(fpr));
    put_u32(static_cast<std::uint32_t>(srl.revoked_artifact_hashes.size()));
    for (const auto& h : srl.revoked_artifact_hashes) put_field(srl_to_lower(h));
    return out;
}
 
// ── parse / serialize (JSON wire form) ───────────────────────────────────────

inline std::optional<SignedRevocationList> parse_srl(std::string_view json,
                                                     std::string& error) {
    SignedRevocationList srl;
    try {
        auto v = choc::json::parse(std::string(json));
        if (!v.isObject()) { error = "SRL is not a JSON object"; return std::nullopt; }
        if (!v.hasObjectMember("epoch") || !v["epoch"].isInt()) {
            error = "missing/invalid integer 'epoch'"; return std::nullopt;
        }
        const std::int64_t raw_epoch = v["epoch"].getInt64();
        if (raw_epoch < 0) { error = "'epoch' must be non-negative"; return std::nullopt; }
        srl.epoch = static_cast<std::uint64_t>(raw_epoch);
 
        if (v.hasObjectMember("schema_version") && v["schema_version"].isInt())
            srl.schema_version = static_cast<int>(v["schema_version"].getInt64());
        if (v.hasObjectMember("issued_utc") && v["issued_utc"].isString())
            srl.issued_utc = v["issued_utc"].getString();
 
        auto read_str_array = [&](const char* key, std::vector<std::string>& dst) -> bool {
            if (!v.hasObjectMember(key)) return true;  // optional
            const auto& arr = v[key];
            if (!arr.isArray()) { error = std::string("'") + key + "' must be an array"; return false; }
            for (uint32_t i = 0; i < arr.size(); ++i) {
                if (!arr[i].isString()) {
                    error = std::string("'") + key + "[" + std::to_string(i) + "]' must be a string";
                    return false;
                }
                dst.push_back(srl_to_lower(std::string(arr[i].getString())));
            }
            return true;
        };
        if (!read_str_array("revoked_signer_key_fprs", srl.revoked_signer_key_fprs)) return std::nullopt;
        if (!read_str_array("revoked_artifact_hashes", srl.revoked_artifact_hashes)) return std::nullopt;
 
        if (v.hasObjectMember("signer") && v["signer"].isString()) {
            if (auto k = srl_hex_decode(v["signer"].getString())) srl.signer_public_key = std::move(*k);
        }
        if (v.hasObjectMember("signature") && v["signature"].isString()) {
            if (auto s = srl_hex_decode(v["signature"].getString())) srl.signature = std::move(*s);
        }
    } catch (const std::exception& e) {
        error = std::string("SRL JSON parse failed: ") + e.what();
        return std::nullopt;
    }
    return srl;
}

inline std::string serialize_srl_json(const SignedRevocationList& srl) {
    auto esc = [](std::string_view s) {
        std::string o;
        o.reserve(s.size() + 2);
        for (char c : s) {
            switch (c) {
                case '"':  o += "\\\""; break;
                case '\\': o += "\\\\"; break;
                case '\n': o += "\\n";  break;
                case '\r': o += "\\r";  break;
                case '\t': o += "\\t";  break;
                default:   o += c;      break;
            }
        }
        return o;
    };
    auto str_array = [&](const std::vector<std::string>& xs) {
        std::string o = "[";
        for (std::size_t i = 0; i < xs.size(); ++i) {
            if (i) o += ",";
            o += "\"" + esc(xs[i]) + "\"";
        }
        o += "]";
        return o;
    };
    std::ostringstream os;
    os << "{"
       << "\"schema_version\":" << srl.schema_version << ","
       << "\"epoch\":" << srl.epoch << ","
       << "\"issued_utc\":\"" << esc(srl.issued_utc) << "\","
       << "\"revoked_signer_key_fprs\":" << str_array(srl.revoked_signer_key_fprs) << ","
       << "\"revoked_artifact_hashes\":" << str_array(srl.revoked_artifact_hashes) << ","
       << "\"signer\":\"" << srl_hex_encode(srl.signer_public_key) << "\","
       << "\"signature\":\"" << srl_hex_encode(srl.signature) << "\""
       << "}";
    return os.str();
}
 
// ── verification ─────────────────────────────────────────────────────────────

inline SrlVerifyResult verify_srl(const SignedRevocationList& srl,
                                  const std::vector<std::uint8_t>& trusted_revocation_pubkey) {
    if (srl.signer_public_key.size() != runtime::ed25519_public_key_size ||
        trusted_revocation_pubkey.size() != runtime::ed25519_public_key_size ||
        srl.signer_public_key != trusted_revocation_pubkey) {
        return {SrlVerify::UntrustedSigner, "SRL signer key is not the trusted revocation key"};
    }
    if (srl.signature.size() != runtime::ed25519_signature_size) {
        return {SrlVerify::BadSignature, "signature size invalid"};
    }
    const auto message = srl_signed_message(srl);
    if (!runtime::ed25519_verify(srl.signer_public_key.data(), srl.signer_public_key.size(),
                                 srl.signature.data(), srl.signature.size(),
                                 message.data(), message.size())) {
        return {SrlVerify::BadSignature, "Ed25519 verification failed"};
    }
    return {SrlVerify::Ok, ""};
}

inline SrlVerifyResult parse_and_verify_srl(std::string_view json,
                                            const std::vector<std::uint8_t>& trusted_revocation_pubkey,
                                            SignedRevocationList& out) {
    std::string err;
    auto parsed = parse_srl(json, err);
    if (!parsed) return {SrlVerify::ParseError, err};
    auto res = verify_srl(*parsed, trusted_revocation_pubkey);
    if (res.ok()) out = std::move(*parsed);
    return res;
}
 
// ── revocation query ─────────────────────────────────────────────────────────

inline bool is_revoked(const SignedRevocationList& srl,
                       std::string_view signer_key_fpr,
                       std::string_view artifact_hash) {
    if (!signer_key_fpr.empty()) {
        const std::string want = srl_to_lower(std::string(signer_key_fpr));
        if (std::find(srl.revoked_signer_key_fprs.begin(),
                      srl.revoked_signer_key_fprs.end(), want) !=
            srl.revoked_signer_key_fprs.end()) {
            return true;
        }
    }
    if (!artifact_hash.empty()) {
        const std::string want = srl_to_lower(std::string(artifact_hash));
        if (std::find(srl.revoked_artifact_hashes.begin(),
                      srl.revoked_artifact_hashes.end(), want) !=
            srl.revoked_artifact_hashes.end()) {
            return true;
        }
    }
    return false;
}
 
// ── namespaced monotonic epoch floor store ───────────────────────────────────

enum class SrlAcceptance {
    Accepted = 0,      
    RejectedRollback,  
    FloorCorrupt,      
    PersistError,      
};

struct SrlFloorState {
    enum class Kind { Absent, Present, Corrupt } kind = Kind::Absent;
    std::uint64_t epoch = 0;                         
    std::optional<SignedRevocationList> last_known;  
};

class EpochFloorStore {
public:
    explicit EpochFloorStore(std::filesystem::path root) : root_(std::move(root)) {}

    static std::string make_namespace(std::string_view plugin_id,
                                      std::string_view revocation_pubkey_fpr,
                                      std::string_view update_channel) {
        auto put = [](std::string& o, std::string_view s) {
            o += std::to_string(s.size());
            o += ':';
            o.append(s.begin(), s.end());
        };
        std::string key;
        put(key, plugin_id);
        put(key, srl_to_lower(std::string(revocation_pubkey_fpr)));
        put(key, update_channel);
        return key;
    }

    std::filesystem::path path_for(std::string_view namespace_key) const {
        return root_ / (runtime::sha256_hex(namespace_key) + ".srl.json");
    }

    SrlFloorState read_floor(std::string_view namespace_key) const {
        const auto p = path_for(namespace_key);
        std::error_code ec;
        if (!std::filesystem::exists(p, ec) || ec) return {};  // Absent
        std::ifstream in(p, std::ios::binary);
        if (!in) return {SrlFloorState::Kind::Corrupt, 0, std::nullopt};
        std::string contents((std::istreambuf_iterator<char>(in)),
                             std::istreambuf_iterator<char>());
        if (in.bad()) return {SrlFloorState::Kind::Corrupt, 0, std::nullopt};
        std::string err;
        auto parsed = parse_srl(contents, err);
        if (!parsed) return {SrlFloorState::Kind::Corrupt, 0, std::nullopt};
        return {SrlFloorState::Kind::Present, parsed->epoch, std::move(parsed)};
    }

    std::optional<SignedRevocationList> last_known(std::string_view namespace_key) const {
        auto st = read_floor(namespace_key);
        if (st.kind == SrlFloorState::Kind::Present) return st.last_known;
        return std::nullopt;
    }

    SrlAcceptance accept_srl(const SignedRevocationList& srl,
                             std::string_view plugin_id,
                             std::string_view revocation_pubkey_fpr,
                             std::string_view update_channel) {
        return accept_srl(srl, make_namespace(plugin_id, revocation_pubkey_fpr, update_channel));
    }

    SrlAcceptance accept_srl(const SignedRevocationList& srl, std::string_view namespace_key) {
        auto st = read_floor(namespace_key);
        if (st.kind == SrlFloorState::Kind::Corrupt) return SrlAcceptance::FloorCorrupt;
        if (st.kind == SrlFloorState::Kind::Present && srl.epoch <= st.epoch) {
            return SrlAcceptance::RejectedRollback;
        }
        return persist(srl, namespace_key) ? SrlAcceptance::Accepted
                                           : SrlAcceptance::PersistError;
    }
 
private:
    bool persist(const SignedRevocationList& srl, std::string_view namespace_key) {
        std::error_code ec;
        std::filesystem::create_directories(root_, ec);
        if (ec) return false;
        const auto target = path_for(namespace_key);
        const auto tmp = std::filesystem::path(target).concat(".tmp");
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out) return false;
            out << serialize_srl_json(srl);
            out.flush();
            if (!out) { std::filesystem::remove(tmp, ec); return false; }
        }
        std::filesystem::rename(tmp, target, ec);
        if (ec) { std::error_code rmec; std::filesystem::remove(tmp, rmec); return false; }
        return true;
    }
 
    std::filesystem::path root_;
};
 
}  // namespace pulp::format::reload