gss_tsig_cfg.h

Go to the documentation of this file.

// Copyright (C) 2021-2025 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef GSS_TSIG_CFG_H
#define GSS_TSIG_CFG_H
 
#include <asiodns/io_fetch.h>
#include <cc/cfg_to_element.h>
#include <cc/simple_parser.h>
#include <cc/user_context.h>
#include <d2srv/d2_cfg_mgr.h>
 
#include <boost/shared_ptr.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/random_access_index.hpp>
 
#include <list>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <vector>
 
namespace isc {
namespace gss_tsig {

class DnsServer : public isc::data::CfgToElement, public isc::data::UserContext {
public:
    static const isc::data::SimpleKeywords SERVER_PARAMETERS;

    static const std::list<std::string> STAT_NAMES;

    DnsServer(const std::string& id,
              const std::set<std::string>& domains,
              const isc::asiolink::IOAddress& ip_address,
              uint16_t port = isc::d2::DnsServerInfo::STANDARD_DNS_PORT);

    virtual ~DnsServer();

    virtual void resetStats();

    std::string getID() const {
        return (id_);
    }

    void setID(const std::string& id) {
        id_ = id;
    }

    const isc::asiolink::IOAddress& getIpAddress() const {
        return (ip_address_);
    }

    isc::asiolink::IntervalTimerPtr& getTimer() {
        return (timer_);
    }

    uint16_t getPort() const {
        return (port_);
    }

    const isc::d2::DnsServerInfoStorage& getServerInfos() const {
        return (server_infos_);
    }

    void addServerInfo(isc::d2::DnsServerInfoPtr server_info) {
        server_infos_.push_back(server_info);
    }

    void clearServerInfos() {
        server_infos_.clear();
    }

    void buildServerInfo(isc::d2::D2CfgContextPtr d2_config);

    const std::string& getServerPrincipal() const {
        return (server_principal_);
    }

    void setServerPrincipal(const std::string& server_principal) {
        server_principal_ = server_principal;
    }

    const std::string& getKeyNameSuffix() const {
        return (key_name_suffix_);
    }

    void setKeyNameSuffix(const std::string& key_name_suffix) {
        key_name_suffix_ = key_name_suffix;
        checkKeyNameSuffix();
    }

    void buildKeyNameSuffix();

    void checkKeyNameSuffix();

    const std::string& getClientPrincipal() const {
        return (cred_principal_);
    }

    void setClientPrincipal(const std::string& cred_principal) {
        cred_principal_ = cred_principal;
    }

    uint32_t getKeyLifetime() const {
        return (tkey_lifetime_);
    }

    bool getGssReplayFlag() const {
        return (gss_replay_flag_);
    }

    void setGssReplayFlag(bool flag) {
        gss_replay_flag_ = flag;
    }

    bool getGssSequenceFlag() const {
        return (gss_sequence_flag_);
    }

    void setGssSequenceFlag(bool flag) {
        gss_sequence_flag_ = flag;
    }

    void setKeyLifetime(uint32_t tkey_lifetime) {
        tkey_lifetime_ = tkey_lifetime;
    }

    uint32_t getRekeyInterval() const {
        return (rekey_interval_);
    }

    void setRekeyInterval(uint32_t rekey_interval) {
        rekey_interval_ = rekey_interval;
    }

    uint32_t getRetryInterval() const {
        return (retry_interval_);
    }

    void setRetryInterval(uint32_t retry_interval) {
        retry_interval_ = retry_interval;
    }

    isc::asiodns::IOFetch::Protocol getKeyProto() const {
        return (tkey_proto_);
    }

    void setKeyProto(isc::asiodns::IOFetch::Protocol tkey_proto) {
        tkey_proto_ = tkey_proto;
    }

    bool getFallback() const {
        return (fallback_);
    }

    void setFallback(bool fallback) {
        fallback_ = fallback;
    }

    uint32_t getExchangeTimeout() const {
        return (exchange_timeout_);
    }

    void setExchangeTimeout(uint32_t exchange_timeout) {
        exchange_timeout_ = exchange_timeout;
    }

    isc::data::ElementPtr toElement() const;

    static constexpr size_t DEFAULT_KEY_LIFETIME = 3600;

    static constexpr size_t DEFAULT_REKEY_INTERVAL = 2700;

    static constexpr size_t DEFAULT_RETRY_INTERVAL = 120;

    static constexpr size_t DEFAULT_EXCHANGE_TIMEOUT = 3000;
 
private:
    void initStats();

    void removeStats();

    void buildServerInfo(isc::d2::DdnsDomainPtr d2_dns_domain);

    std::string id_;

    std::set<std::string> domains_;

    isc::asiolink::IOAddress ip_address_;

    uint16_t port_;

    isc::d2::DnsServerInfoStorage server_infos_;

    std::string server_principal_;

    std::string key_name_suffix_;

    std::string cred_principal_;

    bool gss_replay_flag_;

    bool gss_sequence_flag_;

    uint32_t tkey_lifetime_;

    uint32_t rekey_interval_;

    uint32_t retry_interval_;

    isc::asiodns::IOFetch::Protocol tkey_proto_;

    bool fallback_;

    uint32_t exchange_timeout_;

    isc::asiolink::IntervalTimerPtr timer_;
};

typedef boost::shared_ptr<DnsServer> DnsServerPtr;

struct DnsServerIndexTag { };

struct DnsServerIdTag { };

typedef boost::multi_index_container<
    // Multi index container holding pointers to the DNS servers.
    DnsServerPtr,
    // The following holds all indexes.
    boost::multi_index::indexed_by<
        // First index allows the random access (vector).
        boost::multi_index::random_access<
            boost::multi_index::tag<DnsServerIndexTag>
        >,
        // Second index allows the id access.
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<DnsServerIdTag>,
            boost::multi_index::const_mem_fun<DnsServer, std::string,
                                              &DnsServer::getID>
        >
    >
> DnsServerList;

typedef std::map<isc::d2::DnsServerInfoPtr, DnsServerPtr> DnsServerRevMap;

class GssTsigCfg {
public:
    static const isc::data::SimpleKeywords GLOBAL_PARAMETERS;

    GssTsigCfg();

    virtual ~GssTsigCfg();

    const DnsServerList& getServerList() const {
        return (servers_);
    }

    void addServer(DnsServerPtr server) {
        servers_.push_back(server);
    }

    const DnsServerRevMap& getServerRevMap() const {
        return (servers_rev_map_);
    }

    DnsServerPtr getServer(const isc::d2::DnsServerInfoPtr& server_info) const;

    DnsServerPtr getServer(const std::string& id) const;

    void clearServers() {
        servers_.clear();
        servers_rev_map_.clear();
    }

    void buildServerRevMap(isc::d2::D2CfgContextPtr d2_config);

    const std::string& getClientKeyTab() const {
        return (client_keytab_);
    }

    void setClientKeyTab(const std::string& client_keytab) {
        client_keytab_ = client_keytab;
    }

    const std::string& getCredsCache() const {
        return (creds_cache_);
    }

    void setCredsCache(const std::string& creds_cache) {
        creds_cache_ = creds_cache;
    }

    void configure(isc::data::ConstElementPtr params);

    uint32_t getMaxKeyLifetime() const {
        return (max_tkey_lifetime_);
    }

    void setMaxKeyLifetime(uint32_t max_tkey_lifetime) {
        max_tkey_lifetime_ = max_tkey_lifetime;
    }
 
private:
    DnsServerList servers_;

    DnsServerRevMap servers_rev_map_;

    std::string client_keytab_;

    std::string creds_cache_;

    uint32_t max_tkey_lifetime_;
};
 
} // end of namespace isc::gss_tsig
} // end of namespace isc
 
#endif // GSS_TSIG_CFG_H