Skip to content
This repository was archived by the owner on Feb 17, 2025. It is now read-only.

Commit 0863cde

Browse files
nemothenoonenemothenoone
committed
More refactoring done #1 
1 parent eca0c8d commit 0863cde

File tree

4 files changed

+43
-262
lines changed

4 files changed

+43
-262
lines changed

‎include/nil/crypto3/kdf/algorithm/derive.hpp

+33-253
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,8 @@
11
#ifndef CRYPTO3_KDF_HPP
22
#define CRYPTO3_KDF_HPP
33

4-
#include <boost/assert.hpp>
5-
#include <boost/concept_check.hpp>
6-
7-
#include <boost/core/enable_if.hpp>
8-
9-
#include <boost/range/begin.hpp>
10-
#include <boost/range/end.hpp>
11-
#include <boost/range/concepts.hpp>
12-
#include <boost/range/any_range.hpp>
4+
#include <nil/crypto3/kdf/kdf_value.hpp>
5+
#include <nil/crypto3/kdf/kdf_state.hpp>
136

147
#include <nil/crypto3/detail/type_traits.hpp>
158

@@ -33,295 +26,82 @@ namespace nil {
3326
* @brief Algorithms are meant to provide key derivation interface similar to STL algorithms' one.
3427
*/
3528

36-
namespace detail {
37-
template<typename Hasher, typename SinglePassRange>
38-
using range_stream_hash_traits = typename Hasher::template stream_hash<
39-
std::numeric_limits<
40-
typename std::iterator_traits<typename SinglePassRange::iterator>::value_type>::digits +
41-
std::numeric_limits<typename std::iterator_traits<typename SinglePassRange::iterator>::value_type>::
42-
is_signed>::type;
43-
44-
template<typename Hasher, typename InputIterator>
45-
using iterator_stream_hash_traits = typename Hasher::template stream_hash<
46-
std::numeric_limits<typename std::iterator_traits<InputIterator>::value_type>::digits +
47-
std::numeric_limits<typename std::iterator_traits<InputIterator>::value_type>::is_signed>::type;
48-
49-
#ifdef CRYPTO3_RAW_KDF_STRING_OUTPUT
50-
51-
template<typename Hash, typename InputIterator, typename StreamHasher>
52-
typename Hash::digest_type hash_impl_f(InputIterator first, InputIterator last,
53-
StreamHasher accumulator) {
54-
typedef typename std::iterator_traits<InputIterator>::value_type value_type;
55-
56-
BOOST_STATIC_ASSERT(std::numeric_limits<value_type>::is_specialized);
57-
58-
return accumulator.update(first, last).end_message();
59-
};
60-
61-
template<typename Hash, typename SinglePassRange, typename StreamHasher,
62-
typename = typename std::enable_if<boost::has_range_iterator<SinglePassRange>::value>::type>
63-
typename Hash::digest_type hash_impl_f(const SinglePassRange &rng, StreamHasher accumulator) {
64-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<SinglePassRange>));
65-
66-
typedef typename std::iterator_traits<typename SinglePassRange::iterator>::value_type value_type;
67-
68-
BOOST_STATIC_ASSERT(std::numeric_limits<value_type>::is_specialized);
69-
70-
return accumulator.update(boost::begin(rng), boost::end(rng)).end_message();
71-
}
72-
#else
73-
74-
struct hash_impl {};
75-
76-
template<typename Hasher, typename StreamHash>
77-
struct range_value_hash_impl : public hash_impl {
78-
private:
79-
mutable StreamHash sh;
80-
81-
public:
82-
template<typename SinglePassRange>
83-
range_value_hash_impl(const SinglePassRange &range, StreamHash stream_hash) :
84-
sh(std::move(stream_hash)) {
85-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<SinglePassRange>));
86-
87-
typedef
88-
typename std::iterator_traits<typename SinglePassRange::iterator>::value_type value_type;
89-
90-
BOOST_STATIC_ASSERT(std::numeric_limits<value_type>::is_specialized);
91-
92-
sh.update(boost::begin(range), boost::end(range));
93-
}
94-
95-
template<typename OutputRange>
96-
operator OutputRange() const {
97-
typename Hasher::digest_type range = sh.end_message();
98-
99-
return OutputRange(range.begin(), range.end());
100-
}
101-
102-
operator typename Hasher::digest_type() const {
103-
return sh.end_message();
104-
}
105-
106-
template<typename Char, typename CharTraits, typename Alloc>
107-
operator std::basic_string<Char, CharTraits, Alloc>() const {
108-
return sh.end_message().str();
109-
}
110-
};
111-
112-
template<typename Hasher, typename OutputIterator, typename StreamHash>
113-
struct range_itr_hash_impl : public hash_impl {
114-
private:
115-
mutable StreamHash sh;
116-
117-
mutable OutputIterator out;
118-
119-
public:
120-
template<typename SinglePassRange>
121-
range_itr_hash_impl(const SinglePassRange &range, OutputIterator out, StreamHash stream_hash) :
122-
out(std::move(out)), sh(std::move(stream_hash)) {
123-
BOOST_CONCEPT_ASSERT((boost::SinglePassRangeConcept<SinglePassRange>));
124-
125-
typedef
126-
typename std::iterator_traits<typename SinglePassRange::iterator>::value_type value_type;
127-
128-
BOOST_STATIC_ASSERT(std::numeric_limits<value_type>::is_specialized);
129-
130-
sh.update(boost::begin(range), boost::end(range));
131-
}
132-
133-
operator OutputIterator() const {
134-
const auto &result = sh.end_message();
135-
136-
return std::move(result.begin(), result.end(), std::move(out));
137-
}
138-
};
139-
140-
template<typename Hasher, typename OutputIterator, typename StreamHash>
141-
struct itr_itr_hash_impl : public hash_impl {
142-
private:
143-
mutable StreamHash sh;
144-
145-
mutable OutputIterator out;
146-
147-
public:
148-
template<typename InputIterator>
149-
explicit itr_itr_hash_impl(InputIterator first, InputIterator last, OutputIterator out,
150-
StreamHash stream_hash) :
151-
out(std::move(out)),
152-
sh(std::move(stream_hash)) {
153-
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
154-
155-
typedef typename std::iterator_traits<InputIterator>::value_type value_type;
156-
157-
BOOST_STATIC_ASSERT(std::numeric_limits<value_type>::is_specialized);
158-
159-
sh.update(first, last);
160-
}
161-
162-
operator OutputIterator() const {
163-
const auto &result = sh.end_message();
164-
165-
return std::move(result.begin(), result.end(), std::move(out));
166-
}
167-
};
168-
169-
/*!
170-
* @brief
171-
* @tparam Hasher
172-
* @tparam Input
173-
* @note Such an implementation way is chosen because of no available ways to infer template by
174-
* return type are available. So the type implicit conversion is the way.
175-
*/
176-
template<typename Hasher, typename Input>
177-
class hash {
178-
private:
179-
const detail::hash_impl &impl;
180-
181-
public:
182-
template<typename OutputIterator, typename StreamHash>
183-
explicit hash(Input first, Input last, OutputIterator out, StreamHash sh) :
184-
impl(std::move(detail::itr_itr_hash_impl<Hasher, OutputIterator, StreamHash>(
185-
first, last, std::move(out), std::move(sh)))) {
186-
}
187-
188-
template<typename OutputIterator, typename StreamHash>
189-
explicit hash(const Input &range, OutputIterator out, StreamHash sh) :
190-
impl(std::move(detail::range_itr_hash_impl<Hasher, OutputIterator, StreamHash>(
191-
range, std::move(out), std::move(sh)))) {
192-
}
193-
194-
template<typename StreamHash>
195-
explicit hash(const Input &range, StreamHash sh) :
196-
impl(std::move(detail::range_value_hash_impl<Hasher, StreamHash>(range, sh))) {
197-
}
198-
199-
private:
200-
template<typename OutputIterator,
201-
typename std::enable_if<detail::is_iterator<OutputIterator>::value &&
202-
detail::is_iterator<Input>::value,
203-
bool>::type = false>
204-
OutputIterator to() const {
205-
return static_cast<const detail::itr_itr_hash_impl<
206-
Hasher, OutputIterator, detail::iterator_stream_hash_traits<Hasher, Input>> &>(impl);
207-
}
208-
209-
template<typename OutputIterator,
210-
typename std::enable_if<detail::is_iterator<OutputIterator>::value &&
211-
!detail::is_iterator<Input>::value,
212-
bool>::type = false>
213-
OutputIterator to() const {
214-
return static_cast<const detail::range_itr_hash_impl<
215-
Hasher, OutputIterator, detail::range_stream_hash_traits<Hasher, Input>> &>(impl);
216-
}
217-
218-
template<typename OutputRange, typename std::enable_if<!detail::is_iterator<Input>::value &&
219-
!detail::is_iterator<OutputRange>::value,
220-
bool>::type = false>
221-
OutputRange to() const {
222-
return static_cast<const detail::range_value_hash_impl<
223-
Hasher, detail::range_stream_hash_traits<Hasher, Input>> &>(impl);
224-
}
225-
226-
public:
227-
template<typename Output>
228-
operator Output() const {
229-
return to<Output>();
230-
}
231-
232-
template<typename Char, typename CharTraits, typename Alloc>
233-
operator std::basic_string<Char, CharTraits, Alloc>() const {
234-
return static_cast<const detail::range_value_hash_impl<
235-
Hasher, detail::range_stream_hash_traits<Hasher, Input>> &>(impl);
236-
}
237-
};
238-
239-
#endif
240-
} // namespace detail
241-
24229
/*!
24330
* @brief
24431
*
245-
* @ingroup hash_algorithms
32+
* @ingroup kdf_algorithms
24633
*
247-
* @tparam Hasher
34+
* @tparam Kdf
24835
* @tparam InputIterator
24936
* @tparam OutputIterator
250-
* @tparam StreamHash
37+
* @tparam StreamKdf
25138
* @param first
25239
* @param last
25340
* @param out
25441
* @param sh
25542
* @return
25643
*/
257-
template<typename Hasher, typename InputIterator, typename OutputIterator,
258-
typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>,
259-
typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
260-
OutputIterator hash(InputIterator first, InputIterator last, OutputIterator out,
261-
StreamHash sh = StreamHash()) {
262-
return detail::hash<Hasher, InputIterator>(first, last, std::move(out), std::move(sh));
263-
};
44+
template<typename Kdf, typename InputIterator, typename OutputIterator>
45+
typename std::enable_if<!boost::accumulators::detail::is_accumulator_set<OutputIterator>::value,
46+
OutputIterator>::type
47+
derive(InputIterator first, InputIterator last, OutputIterator out) {
48+
}
26449

26550
/*!
26651
* @brief
26752
*
268-
* @ingroup hash_algorithms
53+
* @ingroup kdf_algorithms
26954
*
270-
* @tparam Hasher
55+
* @tparam Kdf
27156
* @tparam InputIterator
272-
* @tparam StreamHash
57+
* @tparam StreamKdf
27358
* @param first
27459
* @param last
27560
* @param sh
27661
* @return
27762
*/
278-
template<typename Hasher, typename InputIterator,
279-
typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>,
280-
typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
281-
detail::hash<Hasher, InputIterator> hash(InputIterator first, InputIterator last,
282-
StreamHash sh = StreamHash()) {
283-
return detail::hash<Hasher, InputIterator>(boost::any_range(first, last), std::move(sh));
284-
};
63+
template<typename Kdf, typename InputIterator, typename KdfAccumulator = typename kdf::accumulator_set<Kdf>>
64+
typename std::enable_if<boost::accumulators::detail::is_accumulator_set<KdfAccumulator>::value,
65+
KdfAccumulator>::type &
66+
derive(InputIterator first, InputIterator last, KdfAccumulator &acc) {
67+
}
28568

28669
/*!
28770
* @brief
28871
*
289-
* @ingroup hash_algorithms
72+
* @ingroup kdf_algorithms
29073
*
291-
* @tparam Hasher
74+
* @tparam Kdf
29275
* @tparam SinglePassRange
29376
* @tparam OutputIterator
294-
* @tparam StreamHash
77+
* @tparam StreamKdf
29578
* @param rng
29679
* @param out
29780
* @param sh
29881
* @return
29982
*/
300-
template<typename Hasher, typename SinglePassRange, typename OutputIterator,
301-
typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>,
302-
typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
303-
OutputIterator hash(const SinglePassRange &rng, OutputIterator out, StreamHash sh = StreamHash()) {
304-
return detail::hash<Hasher, SinglePassRange>(rng, std::move(out), std::move(sh));
305-
};
83+
template<typename Kdf, typename SinglePassRange, typename OutputIterator>
84+
OutputIterator derive(const SinglePassRange &rng, OutputIterator out) {
85+
}
30686

30787
/*!
30888
* @brief
30989
*
310-
* @ingroup hash_algorithms
90+
* @ingroup kdf_algorithms
31191
*
312-
* @tparam Hasher
92+
* @tparam Kdf
31393
* @tparam SinglePassRange
314-
* @tparam StreamHash
94+
* @tparam StreamKdf
31595
* @param rng
31696
* @param sh
31797
* @return
31898
*/
319-
template<typename Hasher, typename SinglePassRange,
320-
typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>,
321-
typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
322-
detail::hash<Hasher, SinglePassRange> hash(const SinglePassRange &rng, StreamHash sh = StreamHash()) {
323-
return detail::hash<Hasher, SinglePassRange>(rng, std::move(sh));
324-
};
99+
template<typename Kdf, typename SinglePassRange,
100+
typename KdfAccumulator = typename kdf::accumulator_set<Kdf>>
101+
typename std::enable_if<boost::accumulators::detail::is_accumulator_set<KdfAccumulator>::value,
102+
KdfAccumulator>::type &
103+
derive(const SinglePassRange &rng, KdfAccumulator &kdf) {
104+
}
325105
} // namespace kdf
326106
} // namespace crypto3
327107
} // namespace nil

‎include/nil/crypto3/kdf/kdf1_iso18033.hpp

+2
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@ namespace nil {
2424
typedef detail::kdf_iso18033_functions<Hash> policy_type;
2525

2626
public:
27+
typedef typename policy_type::hash_type hash_type;
28+
2729
static void process() {
2830
uint32_t counter = 0;
2931
secure_vector<uint8_t> h;

‎include/nil/crypto3/kdf/kdf_state.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,11 @@
1919
namespace nil {
2020
namespace crypto3 {
2121
namespace kdf {
22-
template<typename MessageAuthenticationCode>
22+
template<typename KeyDerivationFunction>
2323
using accumulator_set = boost::accumulators::accumulator_set<
24-
digest<MessageAuthenticationCode::input_block_bits>,
25-
boost::accumulators::features<accumulators::tag::hash<typename MessageAuthenticationCode::hash_type>,
26-
accumulators::tag::kdf<MessageAuthenticationCode>>>;
24+
digest<KeyDerivationFunction::input_block_bits>,
25+
boost::accumulators::features<accumulators::tag::hash<typename KeyDerivationFunction::hash_type>,
26+
accumulators::tag::kdf<KeyDerivationFunction>>>;
2727
} // namespace kdf
2828
} // namespace crypto3
2929
} // namespace nil

‎include/nil/crypto3/kdf/kdf_value.hpp

+4-5
Original file line numberDiff line numberDiff line change
@@ -10,17 +10,16 @@
1010
#ifndef CRYPTO3_KDF_VALUE_HPP
1111
#define CRYPTO3_KDF_VALUE_HPP
1212

13-
#include <type_traits>
14-
#include <iterator>
15-
1613
#include <boost/assert.hpp>
1714
#include <boost/concept_check.hpp>
1815

1916
#include <boost/range/concepts.hpp>
2017

18+
#include <nil/crypto3/kdf/accumulators/kdf.hpp>
19+
2120
namespace nil {
2221
namespace crypto3 {
23-
namespace mac {
22+
namespace kdf {
2423
namespace detail {
2524
template<typename KdfAccumulator>
2625
struct ref_cipher_impl {
@@ -198,7 +197,7 @@ namespace nil {
198197
}
199198
};
200199
} // namespace detail
201-
} // namespace mac
200+
} // namespace kdf
202201
} // namespace crypto3
203202
} // namespace nil
204203

0 commit comments

Comments
 (0)