signature_types.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kcenon::pacs::security {
 
enum class signature_algorithm {
    rsa_sha256,     
    rsa_sha384,     
    rsa_sha512,     
    ecdsa_sha256,   
    ecdsa_sha384    
};
 
constexpr std::string_view to_string(signature_algorithm algo) {
    switch (algo) {
        case signature_algorithm::rsa_sha256: return "RSA-SHA256";
        case signature_algorithm::rsa_sha384: return "RSA-SHA384";
        case signature_algorithm::rsa_sha512: return "RSA-SHA512";
        case signature_algorithm::ecdsa_sha256: return "ECDSA-SHA256";
        case signature_algorithm::ecdsa_sha384: return "ECDSA-SHA384";
    }
    return "Unknown";
}
 
inline std::optional<signature_algorithm> parse_signature_algorithm(std::string_view str) {
    if (str == "RSA-SHA256") return signature_algorithm::rsa_sha256;
    if (str == "RSA-SHA384") return signature_algorithm::rsa_sha384;
    if (str == "RSA-SHA512") return signature_algorithm::rsa_sha512;
    if (str == "ECDSA-SHA256") return signature_algorithm::ecdsa_sha256;
    if (str == "ECDSA-SHA384") return signature_algorithm::ecdsa_sha384;
    return std::nullopt;
}
 
enum class signature_status {
    valid,              
    invalid,            
    expired,            
    untrusted_signer,   
    revoked,            
    no_signature        
};
 
constexpr std::string_view to_string(signature_status status) {
    switch (status) {
        case signature_status::valid: return "Valid";
        case signature_status::invalid: return "Invalid";
        case signature_status::expired: return "Expired";
        case signature_status::untrusted_signer: return "UntrustedSigner";
        case signature_status::revoked: return "Revoked";
        case signature_status::no_signature: return "NoSignature";
    }
    return "Unknown";
}
 
struct signature_info {
    std::string signature_uid;                      
    std::string signer_name;                        
    std::string signer_organization;                
    std::chrono::system_clock::time_point timestamp; 
    signature_algorithm algorithm;                   
    std::vector<std::uint32_t> signed_tags;         
    std::string certificate_thumbprint;             
 
    bool operator==(const signature_info&) const = default;
};
 
enum class mac_algorithm {
    sha256,         
    sha384,         
    sha512          
};
 
constexpr std::string_view to_dicom_uid(mac_algorithm algo) {
    switch (algo) {
        case mac_algorithm::sha256: return "2.16.840.1.101.3.4.2.1";
        case mac_algorithm::sha384: return "2.16.840.1.101.3.4.2.2";
        case mac_algorithm::sha512: return "2.16.840.1.101.3.4.2.3";
    }
    return "";
}
 
enum class certificate_type {
    x509_certificate,       
    x509_certificate_chain  
};
 
constexpr std::string_view to_dicom_term(certificate_type type) {
    switch (type) {
        case certificate_type::x509_certificate: return "X509_1993_SIG";
        case certificate_type::x509_certificate_chain: return "X509_1993_SIG_CHAIN";
    }
    return "";
}
 
} // namespace kcenon::pacs::security