gss_tsig_api.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_UTIL_H
#define GSS_TSIG_UTIL_H
 
#include <exceptions/exceptions.h>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <gssapi/gssapi_krb5.h>
#include <iostream>
#include <string>
#include <vector>
 
namespace isc {
namespace gss_tsig {

class GssApiError : public Exception {
public:
    GssApiError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {
    }
};
 
class GssCredExpired : public Exception {
public:
    GssCredExpired(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {
    }
};

class GssApiLastError {
public:
    GssApiLastError();

    virtual ~GssApiLastError();

    int getLastError() const {
        return (last_error_);
    }

    void setLastError(int error) {
        last_error_ = error;
    }
 
private:
    int last_error_;
};

std::string gssApiErrMsg(OM_uint32 major, OM_uint32 minor);

class GssApiBuffer : public boost::noncopyable {
public:
    GssApiBuffer();

    GssApiBuffer(size_t length, const void* value);

    explicit GssApiBuffer(const std::vector<uint8_t>& content);

    explicit GssApiBuffer(const std::string& content);

    ~GssApiBuffer();

    bool empty() const {
        return (buffer_.value == 0);
    }

    gss_buffer_t getPtr() {
        return (&buffer_);
    }

    size_t getLength() const {
        return (buffer_.length);
    }

    void* getValue() {
        return (buffer_.value);
    }

    std::vector<uint8_t> getContent() const;

    std::string getString(bool trim = false) const;
 
private:
    gss_buffer_desc buffer_;
};

typedef boost::shared_ptr<GssApiBuffer> GssApiBufferPtr;


class GssApiName : public boost::noncopyable, public GssApiLastError {
public:
    GssApiName();

    explicit GssApiName(const std::string& gname);

    ~GssApiName();

    gss_name_t get() {
        return (name_);
    }

    gss_name_t* getPtr() {
        return (&name_);
    }

    bool compare(GssApiName& other);

    std::string toString();
 
private:
    gss_name_t name_;
};

typedef boost::shared_ptr<GssApiName> GssApiNamePtr;

class GssApiCred : public boost::noncopyable, public GssApiLastError {
public:
    GssApiCred();

    GssApiCred(GssApiName& gname, gss_cred_usage_t cred_usage,
               OM_uint32& lifetime);

    ~GssApiCred();

    gss_cred_id_t get() {
        return (cred_);
    }

    void inquire(GssApiName& name, gss_cred_usage_t& cred_usage,
                 OM_uint32& lifetime);
 
private:
    gss_cred_id_t cred_;
};

typedef boost::shared_ptr<GssApiCred> GssApiCredPtr;

class GssApiSecCtx : public boost::noncopyable, public GssApiLastError {
public:
    explicit GssApiSecCtx(gss_ctx_id_t sec_ctx);

    explicit GssApiSecCtx(const std::vector<uint8_t>& import);

    ~GssApiSecCtx();

    gss_ctx_id_t get() {
        return (sec_ctx_);
    }

    gss_ctx_id_t* getPtr() {
        return (&sec_ctx_);
    }

    std::vector<uint8_t> serialize();

    OM_uint32 getLifetime();

    void inquire(GssApiName& source, GssApiName& target, OM_uint32& lifetime,
                 OM_uint32& flags, bool& local, bool& established);

    void sign(GssApiBuffer& gmessage, GssApiBuffer& gsig);

    void verify(GssApiBuffer& gmessage, GssApiBuffer& gsig);

    bool init(GssApiCredPtr credp, GssApiName& target, OM_uint32 flags,
              GssApiBuffer& intoken, GssApiBuffer& outtoken,
              OM_uint32& lifetime);

    bool accept(GssApiCred& cred, GssApiBuffer& intoken, GssApiName& source,
                GssApiBuffer& outtoken);
 
private:
    gss_ctx_id_t sec_ctx_;
};

class GssApiOid : public boost::noncopyable {
public:
    GssApiOid();

    explicit GssApiOid(const std::vector<uint8_t>& elements);

    explicit GssApiOid(const std::string& str);

    ~GssApiOid();

    gss_OID get() {
        return (oid_);
    }

    std::string toString();
 
private:
    gss_OID oid_;
};

extern GssApiOid ISC_GSS_KRB5_MECHANISM;

extern GssApiOid ISC_GSS_SPNEGO_MECHANISM;

typedef boost::shared_ptr<GssApiOid> GssApiOidPtr;

class GssApiOidSet : public boost::noncopyable {
public:
    explicit GssApiOidSet(bool fill = true);

    ~GssApiOidSet();

    gss_OID_set get() {
        return (oid_set_);
    }
 
private:
    gss_OID_set oid_set_;
};

typedef boost::shared_ptr<GssApiOidSet> GssApiOidSetPtr;
 
} // end of namespace isc::gss_tsig
} // end of namespace isc
 
#endif // GSS_TSIG_UTIL_H