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
146
147
148
149
150
|
/*
* rfc4251.h -- implements types from RFC 4251, section 5
*
* rfc4251::byte byte
* rfc4251::boolean boolean
* rfc4251::uint32 uint32
* rfc4251::uint64 uint64
* rfc4251::string string, incl. mpint and name-list
*
* those structs contain the objects in their RFC 4251 representation,
* conversions are provided via constructors and cast operators
*
* Copyright (C) 2013-2015,2021 Timo Weingärtner <timo@tiwe.de>
*
* This file is part of ssh-agent-filter.
*
* ssh-agent-filter is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ssh-agent-filter is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ssh-agent-filter. If not, see <http://www.gnu.org/licenses/>.
*/
#include <type_traits>
#include <cstdint>
#include <array>
#include <vector>
#include <string>
#include <iostream>
#include <limits>
#include <stdexcept>
#include <gmpxx.h>
#include <boost/operators.hpp>
namespace rfc4251 {
namespace internal {
template<typename T>
constexpr inline auto host_to_network (T value) noexcept {
static_assert(std::is_unsigned_v<T>, "shift is only supported on unsigned");
std::array<char, sizeof(T)> ret;
for (auto it{rbegin(ret)}; it != rend(ret); ++it) {
*it = value & 0xff;
if constexpr (sizeof(T) > 1) value >>= 8;
}
return ret;
}
template<typename T>
constexpr inline auto network_to_host (std::array<char, sizeof(T)> const buf) noexcept {
static_assert(std::is_unsigned_v<T>, "shift is only supported on unsigned");
T ret{0};
for (auto it{cbegin(buf)}; it != cend(buf); ++it) {
if constexpr (sizeof(T) > 1) ret <<= 8;
ret |= static_cast<uint8_t>(*it);
}
return ret;
}
template<typename T>
struct fixed_length {
static_assert(std::is_unsigned_v<T>, "support for signed types might need more work");
std::array<char, sizeof(T)> buf{};
constexpr fixed_length () noexcept = default;
constexpr explicit fixed_length (T const v) noexcept : buf{host_to_network(v)} {}
explicit fixed_length (std::istream & is) { is >> *this; }
constexpr operator T () const noexcept { return network_to_host<T>(buf); }
friend std::istream & operator>> (std::istream & is, fixed_length & x) {
return is.read(x.buf.data(), x.buf.size());
}
friend std::ostream & operator<< (std::ostream & os, fixed_length const & x) {
return os.write(x.buf.data(), x.buf.size());
}
};
}
using byte = internal::fixed_length<uint8_t>;
using boolean = internal::fixed_length<bool>;
using uint32 = internal::fixed_length<uint32_t>;
using uint64 = internal::fixed_length<uint64_t>;
struct string : boost::totally_ordered<string> {
std::vector<char> value;
string () = default;
inline explicit string (char const *, size_t);
explicit string (std::string const & s) : string{s.data(), s.size()} {}
explicit string (std::vector<std::string> const &);
explicit string (mpz_srcptr);
explicit string (mpz_class const & x) : string{x.get_mpz_t()} {}
inline explicit string (std::istream &);
size_t size () const noexcept { return value.size(); }
char const * data () const noexcept { return value.data(); }
char * data () noexcept { return value.data(); }
operator std::string () const { return {value.begin(), value.end()}; }
operator std::vector<std::string> () const;
operator mpz_class () const;
};
inline string::string (char const * s, size_t l) {
if (l > std::numeric_limits<uint32_t>::max())
throw std::length_error{"32-bit limit for rfc4251::string exceeded"};
value.insert(value.end(), s, s + l);
}
inline std::istream & operator>> (std::istream & is, string & s) {
s.value.clear();
if (uint32_t const len{uint32{is}}; is) {
s.value.resize(len);
is.read(s.value.data(), len);
}
return is;
}
inline std::ostream & operator<< (std::ostream & os, string const & s) {
if (s.value.size() > std::numeric_limits<uint32_t>::max())
throw std::length_error{"32-bit limit for rfc4251::string exceeded"};
if (os << uint32{static_cast<uint32_t>(s.value.size())})
os.write(s.value.data(), s.value.size());
return os;
}
inline string::string (std::istream & is) {
is >> *this;
}
inline bool operator== (string const & l, string const & r) {
return l.value == r.value;
}
inline bool operator< (string const & l, string const & r) {
return l.value < r.value;
}
}
|
