1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
// Copyright (C) 2018-2022 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 OPTION6_AUTH_H
#define OPTION6_AUTH_H
#endif

#include <dhcp/option.h>
#include <boost/shared_ptr.hpp><--- Include file:  not found. Please note: Cppcheck does not need standard library headers to get proper results.

#include <vector><--- Include file:  not found. Please note: Cppcheck does not need standard library headers to get proper results.

namespace isc {
namespace dhcp {

class Option6Auth;

/// A pointer to the @c isc::dhcp::Option6Auth object.
typedef boost::shared_ptr<Option6Auth> Option6AuthPtr;

/// @brief This class represents Authentication (11) DHCPv6 option.
///
/// For details, see RFC 8415 Section 21.11.
class Option6Auth: public Option {

public:
    static const uint8_t OPTION6_AUTH_MIN_LEN  = 11;
    static const uint8_t OPTION6_HASH_MSG_LEN  = 16;
    static const uint8_t OPTION6_HDR = 4;
    /// @brief Constructor, used for auth options while transmitting
    ///
    /// @param proto protocol type
    /// @param algo algorithm type
    /// @param method remote detection method
    /// @param rdm replay detection value
    /// @param info authentication info.
    Option6Auth(const uint8_t proto, const uint8_t algo, const uint8_t method,
                const uint64_t rdm, const std::vector<uint8_t>& info);

    /// @brief Copies this option and returns a pointer to the copy.
    virtual OptionPtr clone() const;

    /// Writes option in wire-format to buf, returns pointer to first unused
    /// byte after stored option.
    ///
    /// @param buf buffer (option will be stored here)
    /// @param check if set to false, allows options larger than 255 for v4
    void pack(isc::util::OutputBuffer& buf, bool check = true) const;<--- Function in derived class

    /// Writes option in wire-format to buf, for computing hash
    /// auth info filled with 0 for a length of 128 bits
    /// returns with pointer to first unused
    /// byte after stored option.
    ///
    /// @param buf buffer (option will be stored here)
    void packHashInput(isc::util::OutputBuffer& buf) const;

    /// @brief Parses received buffer
    ///
    /// Parses received buffer and returns offset to the first unused byte after
    /// parsed option.
    ///
    /// @param begin iterator to first byte of option data
    /// @param end iterator to end of option data (first byte after option end)
    virtual void unpack(OptionBufferConstIter begin, OptionBufferConstIter end);

    /// Provides human readable text representation
    ///
    /// @param indent number of leading space characters
    ///
    /// @return string with text representation
    virtual std::string toText(int indent = 0) const;<--- Function in derived class

    /// Set protocol type
    ///
    /// @param proto protocol type to be set
    void setProtocol(uint8_t proto) { protocol_ = proto; }

    /// Set hash algorithm type
    ///
    /// @param algo hash algorithm type to be set
    void setHashAlgo(uint8_t algo) { algorithm_ = algo; }

    /// Set replay detection method type
    ///
    /// @param method replay detection method to be set
    void setReplyDetectionMethod(uint8_t method) { rdm_method_ = method; }

    /// Set replay detection method value
    ///
    /// @param value replay detection method value to be set
    void setReplyDetectionValue(uint64_t value) { rdm_value_ = value; }

    /// Set authentication information
    ///
    /// @param auth_info authentication information to be set
    void setAuthInfo(const std::vector<uint8_t>& auth_info) { auth_info_ = auth_info; }

    /// Returns protocol type
    ///
    /// @return protocol value
    uint8_t getProtocol() const { return protocol_; }

    /// Returns hash algorithm type
    ///
    /// @return hash algorithm value
    uint8_t getHashAlgo() const { return algorithm_; }

    /// Returns replay detection method type
    ///
    /// @return replay detection method type value
    uint8_t getReplyDetectionMethod() const { return rdm_method_; }

    /// Return replay detection mechanism
    ///
    /// @return replay detection method value
    uint64_t getReplyDetectionValue() const { return rdm_value_; }

    /// Return authentication information
    ///
    /// @return authentication information value
    std::vector<uint8_t> getAuthInfo() const { return auth_info_; }<--- Function 'getAuthInfo()' should return member 'auth_info_' by const reference.

protected:
    /// keeps protocol type
    uint8_t protocol_;

    /// keeps hash algorithm value
    uint8_t algorithm_;

    /// keeps replay detection method type
    uint8_t rdm_method_;

    /// keeps replay detection method value
    uint64_t rdm_value_;

    /// keeps authentication information
    std::vector<uint8_t> auth_info_;
};

} // isc::dhcp namespace
} // isc namespace