client_message.h

Go to the documentation of this file.

// Copyright (C) 2023-2026 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 RADIUS_CLIENT_MESSAGE_H
#define RADIUS_CLIENT_MESSAGE_H
 
#include <client_attribute.h>
#include <exceptions/exceptions.h>
#include <asiolink/io_address.h>
#include <tcp/wire_data.h>
#include <string>
#include <vector>
 
namespace isc {
namespace radius {

enum MsgCode : uint8_t {
    PW_ACCESS_REQUEST              = 1,
    PW_ACCESS_ACCEPT               = 2,
    PW_ACCESS_REJECT               = 3,
    PW_ACCOUNTING_REQUEST          = 4,
    PW_ACCOUNTING_RESPONSE         = 5,
    PW_ACCOUNTING_STATUS           = 6,
    PW_PASSWORD_REQUEST            = 7,
    PW_PASSWORD_ACK                = 8,
    PW_PASSWORD_REJECT             = 9,
    PW_ACCOUNTING_MESSAGE          = 10,
    PW_ACCESS_CHALLENGE            = 11,
    PW_STATUS_SERVER               = 12,
    PW_STATUS_CLIENT               = 13
};

std::string msgCodeToText(const uint8_t code);

static constexpr size_t AUTH_HDR_LEN = 20;

static constexpr size_t PW_MAX_MSG_SIZE = 4095;

static constexpr size_t AUTH_VECTOR_LEN = 16;

static constexpr size_t AUTH_PASS_LEN = 128;

class Message {
public:
    static const std::vector<uint8_t> ZERO_AUTH() {
        static std::vector<uint8_t> zero(AUTH_VECTOR_LEN, 0);
        return (zero);
    }

    Message(const uint8_t code, uint16_t length,
            const std::vector<uint8_t>& auth,
            const std::string& secret,
            const AttributesPtr& attributes);

    Message(const Message& other);

    Message(const std::vector<uint8_t>& buffer,
            const std::vector<uint8_t>& auth,
            const std::string& secret);

    virtual ~Message();

    uint8_t getCode() const {
        return (code_);
    }

    void setCode(const uint8_t code) {
        code_ = code;
    }

    uint8_t getIdentifier() const {
        return(identifier_);
    }

    void setIdentifier(const uint8_t identifier) {
        identifier_ = identifier;
    }

    void randomIdentifier();

    uint16_t getLength() const {
        return (length_);
    }

    void setLength(const uint16_t length) {
        length_ = length;
    }

    std::vector<uint8_t> getAuth() const {
        return (auth_);
    }

    void setAuth(const std::vector<uint8_t>& auth);

    void zeroAuth();

    void randomAuth();

    std::string getSecret() const {
        return (secret_);
    }

    void setSecret(const std::string& secret);

    AttributesPtr getAttributes() const {
        return (attributes_);
    }

    void setAttributes(const AttributesPtr& attributes) {
        attributes_ = attributes;
    }

    std::vector<uint8_t> getBuffer() const {
        return (buffer_);
    }

    void setBuffer(const std::vector<uint8_t>& buffer) {
        buffer_ = buffer;
    }

    std::vector<uint8_t> encode();

    void decode();
 
protected:
    ConstAttributePtr encodeUserPassword(const ConstAttributePtr& attr);

    ConstAttributePtr decodeUserPassword(const ConstAttributePtr& attr);

    void signMessageAuthenticator(size_t ptr);

    void verifyMessageAuthenticator(size_t ptr);

    uint8_t code_;

    uint8_t identifier_;

    uint16_t length_;

    std::vector<uint8_t> auth_;

    std::string secret_;

    AttributesPtr attributes_;

    std::vector<uint8_t> buffer_;
};

typedef boost::shared_ptr<Message> MessagePtr;
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif