/src/cryptofuzz/mutator.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | #include <cstdint> |
2 | | #include <array> |
3 | | #include <fuzzing/datasource/datasource.hpp> |
4 | | #include <fuzzing/datasource/id.hpp> |
5 | | #include <cryptofuzz/operations.h> |
6 | | #include <cryptofuzz/repository.h> |
7 | | #include <cryptofuzz/options.h> |
8 | | #include <cryptofuzz/util.h> |
9 | | #include <boost/multiprecision/cpp_int.hpp> |
10 | | #include <boost/lexical_cast.hpp> |
11 | | #include <boost/random.hpp> |
12 | | #include <algorithm> |
13 | | #include <random> |
14 | | #include "config.h" |
15 | | #include "repository_tbl.h" |
16 | | #include "numbers.h" |
17 | | #include "mutatorpool.h" |
18 | | #include "_z3.h" |
19 | | #include "expmod.h" |
20 | | #include "third_party/json/json.hpp" |
21 | | |
22 | | extern "C" size_t LLVMFuzzerMutate(uint8_t* data, size_t size, size_t maxSize); |
23 | | |
24 | | uint32_t PRNG(void) |
25 | 28.0k | { |
26 | 28.0k | static uint32_t nSeed = 5323; |
27 | 28.0k | nSeed = (8253729 * nSeed + 2396403); |
28 | 28.0k | return nSeed % 32767; |
29 | 28.0k | } |
30 | | |
31 | | auto rng = std::default_random_engine {}; |
32 | | |
33 | | boost::multiprecision::cpp_int cpp_int_reciprocal( |
34 | | boost::multiprecision::cpp_int x, |
35 | 0 | boost::multiprecision::cpp_int m) { |
36 | 0 | if ( x == 0 || x >= m ) { |
37 | 0 | return x; |
38 | 0 | } |
39 | 0 | boost::multiprecision::cpp_int y = x; |
40 | 0 | x = m; |
41 | 0 | boost::multiprecision::cpp_int a = 0; |
42 | 0 | boost::multiprecision::cpp_int b = 1; |
43 | 0 | while ( y != 0 ) { |
44 | 0 | boost::multiprecision::cpp_int tmp; |
45 | |
|
46 | 0 | tmp = a; |
47 | 0 | a = b; |
48 | 0 | b = tmp - x / y * b; |
49 | |
|
50 | 0 | tmp = x; |
51 | 0 | x = y; |
52 | 0 | y = tmp % y; |
53 | 0 | } |
54 | |
|
55 | 0 | if ( x == 1 ) { |
56 | 0 | return a % m; |
57 | 0 | } |
58 | | |
59 | 0 | return 0; |
60 | 0 | } |
61 | | |
62 | 0 | static size_t cpp_int_num_bits(const boost::multiprecision::cpp_int& m) { |
63 | 0 | boost::multiprecision::cpp_int m_copy = m; |
64 | |
|
65 | 0 | size_t num_bits = 0; |
66 | 0 | while ( m_copy ) { |
67 | 0 | m_copy >>= 1; |
68 | 0 | num_bits++; |
69 | 0 | } |
70 | 0 | num_bits = (num_bits / 8 + 1) * 8; |
71 | |
|
72 | 0 | return num_bits; |
73 | 0 | } |
74 | | |
75 | 0 | static std::string to_mont(const std::string& y_, const std::string& mod_) { |
76 | 0 | if ( y_ == "" || (y_.size() && (y_[0] == '0' || y_[0] == '-')) ) { |
77 | 0 | return y_; |
78 | 0 | } |
79 | 0 | if ( mod_ == "" || (mod_.size() && (mod_[0] == '0' || mod_[0] == '-')) ) { |
80 | 0 | return y_; |
81 | 0 | } |
82 | 0 | const boost::multiprecision::cpp_int mod(mod_); |
83 | 0 | const boost::multiprecision::cpp_int y(y_); |
84 | 0 | const boost::multiprecision::cpp_int res = (y << cpp_int_num_bits(mod)) % mod; |
85 | 0 | return res.str(); |
86 | 0 | } |
87 | | |
88 | 0 | static std::string from_mont(const std::string& y_, const std::string& mod_) { |
89 | 0 | if ( y_ == "" || (y_.size() && (y_[0] == '0' || y_[0] == '-')) ) { |
90 | 0 | return y_; |
91 | 0 | } |
92 | 0 | if ( mod_ == "" || (mod_.size() && (mod_[0] == '0' || mod_[0] == '-')) ) { |
93 | 0 | return y_; |
94 | 0 | } |
95 | 0 | const boost::multiprecision::cpp_int mod(mod_); |
96 | 0 | const auto num_bits = cpp_int_num_bits(mod); |
97 | 0 | boost::multiprecision::cpp_int reducer = 1; |
98 | 0 | reducer <<= num_bits; |
99 | 0 | const auto multiplier = cpp_int_reciprocal(reducer % mod, mod); |
100 | 0 | const boost::multiprecision::cpp_int y(y_); |
101 | 0 | const boost::multiprecision::cpp_int res = (y * multiplier) % mod; |
102 | 0 | return res.str(); |
103 | 0 | } |
104 | | |
105 | 0 | static std::string mutateBinary(const std::string s) { |
106 | 0 | if ( s.size() && s[0] == '0' ) { |
107 | 0 | return s; |
108 | 0 | } |
109 | 0 | if ( s.size() && s[0] == '-' ) { |
110 | 0 | return s; |
111 | 0 | } |
112 | | |
113 | 0 | const auto i = boost::multiprecision::cpp_int(s); |
114 | |
|
115 | 0 | std::vector<uint8_t> bytes; |
116 | 0 | export_bits(i, std::back_inserter(bytes), 8); |
117 | 0 | auto newsize = LLVMFuzzerMutate(bytes.data(), bytes.size(), bytes.size()); |
118 | | |
119 | | /* Memory sanitizer doesn't like that LLVMFuzzerMutate is called. |
120 | | * If MSAN is enabled, manually unpoison the region returned by |
121 | | * LLVMFuzzerMutate. |
122 | | */ |
123 | 0 | cryptofuzz::util::MemorySanitizerUnpoison(bytes.data(), newsize); |
124 | |
|
125 | 0 | bytes.resize(newsize); |
126 | 0 | if ( newsize ) { |
127 | 0 | newsize = PRNG() % (newsize+1); |
128 | 0 | if ( newsize ) { |
129 | 0 | bytes.resize(newsize); |
130 | 0 | } |
131 | 0 | } |
132 | 0 | boost::multiprecision::cpp_int j; |
133 | 0 | import_bits(j, bytes.begin(), bytes.end()); |
134 | |
|
135 | 0 | return j.str(); |
136 | 0 | } |
137 | | |
138 | 0 | std::optional<std::string> get_op_mod(const uint64_t& operation) { |
139 | 0 | switch ( operation ) { |
140 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp64"): |
141 | 0 | return "18446744073709551616"; |
142 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp128"): |
143 | 0 | return "340282366920938463463374607431768211456"; |
144 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp256"): |
145 | 0 | return "115792089237316195423570985008687907853269984665640564039457584007913129639936"; |
146 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp512"): |
147 | 0 | return "13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"; |
148 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_381_P"): |
149 | 0 | return "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"; |
150 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_381_R"): |
151 | 0 | return "52435875175126190479447740508185965837690552500527637822603658699938581184513"; |
152 | 0 | case CF_OPERATION("BignumCalc_Mod_BN128_P"): |
153 | 0 | return "21888242871839275222246405745257275088696311157297823662689037894645226208583"; |
154 | 0 | case CF_OPERATION("BignumCalc_Mod_BN128_R"): |
155 | 0 | return "21888242871839275222246405745257275088548364400416034343698204186575808495617"; |
156 | 0 | case CF_OPERATION("BignumCalc_Mod_ED25519"): |
157 | 0 | return "57896044618658097711785492504343953926634992332820282019728792003956564819949"; |
158 | 0 | case CF_OPERATION("BignumCalc_Mod_Edwards_P"): |
159 | 0 | return "6210044120409721004947206240885978274523751269793792001"; |
160 | 0 | case CF_OPERATION("BignumCalc_Mod_Edwards_R"): |
161 | 0 | return "1552511030102430251236801561344621993261920897571225601"; |
162 | 0 | case CF_OPERATION("BignumCalc_Mod_SECP256K1"): |
163 | 0 | return "115792089237316195423570985008687907852837564279074904382605163141518161494337"; |
164 | 0 | case CF_OPERATION("BignumCalc_Mod_SECP256K1_P"): |
165 | 0 | return "115792089237316195423570985008687907853269984665640564039457584007908834671663"; |
166 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_377_P"): |
167 | 0 | return "258664426012969094010652733694893533536393512754914660539884262666720468348340822774968888139573360124440321458177"; |
168 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_377_R"): |
169 | 0 | return "8444461749428370424248824938781546531375899335154063827935233455917409239041"; |
170 | | /* TODO the rest */ |
171 | 0 | default: |
172 | 0 | return std::nullopt; |
173 | 0 | } |
174 | 0 | } |
175 | | |
176 | 0 | static uint64_t PRNG64(void) { |
177 | 0 | return (((uint64_t)PRNG()) << 32) + PRNG(); |
178 | 0 | } |
179 | | |
180 | 0 | static std::vector<size_t> SplitLength(size_t left, const size_t numParts) { |
181 | 0 | std::vector<size_t> lengths; |
182 | 0 | for (size_t i = 0; i < numParts; i++) { |
183 | 0 | const auto cur = PRNG() % (left+1); |
184 | 0 | lengths.push_back(cur); |
185 | 0 | left -= cur; |
186 | 0 | } |
187 | |
|
188 | 0 | std::vector<size_t> lengths_randomized; |
189 | 0 | for (size_t i = 0; i < numParts; i++) { |
190 | 0 | const auto cur = lengths.begin() + PRNG() % (lengths.size()); |
191 | 0 | lengths_randomized.push_back(*cur); |
192 | 0 | lengths.erase(cur); |
193 | 0 | } |
194 | |
|
195 | 0 | return lengths_randomized; |
196 | 0 | } |
197 | | |
198 | 0 | bool getBool(void) { |
199 | 0 | return PRNG() % 2 == 0; |
200 | 0 | } |
201 | | |
202 | 0 | static size_t getDefaultSize(void) { |
203 | 0 | static const std::array defaultSizes = {0, 1, 2, 4, 8, 12, 16, 24, 32, 64}; |
204 | |
|
205 | 0 | return defaultSizes[PRNG() % defaultSizes.size()]; |
206 | 0 | } |
207 | | |
208 | 0 | static std::string getBuffer(size_t size, const bool alternativeSize = false) { |
209 | 0 | static const std::array<std::string, 256> hex = { |
210 | 0 | "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", |
211 | 0 | "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", |
212 | 0 | "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", |
213 | 0 | "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", |
214 | 0 | "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", |
215 | 0 | "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b", "5c", "5d", "5e", "5f", |
216 | 0 | "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", |
217 | 0 | "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", |
218 | 0 | "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f", |
219 | 0 | "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", |
220 | 0 | "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", |
221 | 0 | "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", |
222 | 0 | "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", |
223 | 0 | "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", |
224 | 0 | "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", |
225 | 0 | "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"}; |
226 | |
|
227 | 0 | if ( alternativeSize == true ) { |
228 | 0 | if ( getBool() ) { |
229 | 0 | const auto newSize = getDefaultSize(); |
230 | 0 | if ( newSize < size ) { |
231 | 0 | size = newSize; |
232 | 0 | } |
233 | 0 | } |
234 | 0 | } |
235 | |
|
236 | 0 | std::string ret; |
237 | |
|
238 | 0 | for (size_t i = 0; i < size; i++) { |
239 | 0 | ret += hex[PRNG() % 256]; |
240 | 0 | } |
241 | |
|
242 | 0 | return ret; |
243 | 0 | } |
244 | | |
245 | 0 | static std::vector<uint8_t> getBufferBin(const size_t size) { |
246 | 0 | std::vector<uint8_t> ret(size); |
247 | |
|
248 | 0 | for (size_t i = 0; i < size; i++) { |
249 | 0 | ret[i] = PRNG(); |
250 | 0 | } |
251 | |
|
252 | 0 | return ret; |
253 | 0 | } |
254 | | |
255 | 0 | std::string getBignum(bool mustBePositive = false) { |
256 | 0 | std::string ret; |
257 | |
|
258 | 0 | if ( (PRNG() % 10) == 0 ) { |
259 | 0 | constexpr long sizeMax = cryptofuzz::config::kMaxBignumSize; |
260 | 0 | constexpr long sizeTop = sizeMax * 0.5; |
261 | 0 | constexpr long sizeBottom = sizeMax - sizeTop; |
262 | |
|
263 | 0 | static_assert(sizeBottom > 0); |
264 | 0 | static_assert(sizeBottom + sizeTop <= sizeMax); |
265 | |
|
266 | 0 | const size_t size = (PRNG() % sizeTop) + sizeBottom; |
267 | |
|
268 | 0 | for (size_t i = 0; i < size; i++) { |
269 | 0 | char c = '0' + (PRNG() % 10); |
270 | 0 | if ( i == 0 && c == '0' ) { |
271 | | /* Cannot have leading zeroes */ |
272 | 0 | c = '1'; |
273 | 0 | } |
274 | 0 | ret += c; |
275 | 0 | } |
276 | 0 | } else { |
277 | 0 | if ( getBool() ) { |
278 | 0 | ret = Pool_Bignum.Get(); |
279 | 0 | } else { |
280 | 0 | ret = cryptofuzz::numbers.at(PRNG() % cryptofuzz::numbers.size()); |
281 | 0 | } |
282 | 0 | } |
283 | |
|
284 | 0 | const bool isNegative = !ret.empty() && ret[0] == '-'; |
285 | 0 | if ( cryptofuzz::config::kNegativeIntegers == false ) { |
286 | 0 | mustBePositive = true; |
287 | 0 | } |
288 | |
|
289 | 0 | if ( isNegative && mustBePositive ) { |
290 | 0 | ret = std::string(ret.data() + 1, ret.size() - 1); |
291 | 0 | } |
292 | |
|
293 | 0 | if ( !mustBePositive && !isNegative && getBool() ) { |
294 | 0 | ret = "-" + ret; |
295 | 0 | } |
296 | |
|
297 | 0 | return ret; |
298 | 0 | } |
299 | | |
300 | 0 | std::string getPrime(void) { |
301 | 0 | return Pool_Bignum_Primes.Get(); |
302 | 0 | } |
303 | | |
304 | 0 | uint64_t hint_ecc_mont(const uint64_t& curveType) { |
305 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(curveType); |
306 | |
|
307 | 0 | if ( order != std::nullopt ) { |
308 | 0 | const auto v = from_mont(mutateBinary(getBignum()), *order); |
309 | |
|
310 | 0 | Pool_Bignum.Set(v); |
311 | 0 | } |
312 | |
|
313 | 0 | return curveType; |
314 | 0 | } |
315 | | |
316 | | #if 0 |
317 | | std::string to_mont(const std::string& y_) { |
318 | | static const boost::multiprecision::cpp_int mod("4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"); |
319 | | const boost::multiprecision::cpp_int y(y_); |
320 | | const boost::multiprecision::cpp_int res = (y << 384) % mod; |
321 | | return res.str(); |
322 | | } |
323 | | std::string from_mont(const std::string& y_) { |
324 | | static const boost::multiprecision::cpp_int multiplier("3231460744492646417066832100176244795738767926513225105051837195607029917124509527734802654356338138714468589979680"); |
325 | | static const boost::multiprecision::cpp_int mod("4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"); |
326 | | const boost::multiprecision::cpp_int y(y_); |
327 | | const boost::multiprecision::cpp_int res = (y * multiplier) % mod; |
328 | | return res.str(); |
329 | | } |
330 | | #endif |
331 | | |
332 | | extern cryptofuzz::Options* cryptofuzz_options; |
333 | | |
334 | 0 | static uint64_t getRandomCipher(void) { |
335 | 0 | if ( !cryptofuzz_options->ciphers.Empty() ) { |
336 | 0 | return cryptofuzz_options->ciphers.At(PRNG()); |
337 | 0 | } else { |
338 | 0 | return CipherLUT[ PRNG() % (sizeof(CipherLUT) / sizeof(CipherLUT[0])) ].id; |
339 | 0 | } |
340 | 0 | } |
341 | | |
342 | 0 | static uint64_t getRandomDigest(void) { |
343 | 0 | if ( !cryptofuzz_options->digests.Empty() ) { |
344 | 0 | return cryptofuzz_options->digests.At(PRNG()); |
345 | 0 | } else { |
346 | 0 | return DigestLUT[ PRNG() % (sizeof(DigestLUT) / sizeof(DigestLUT[0])) ].id; |
347 | 0 | } |
348 | 0 | } |
349 | | |
350 | 0 | static uint64_t getRandomCurve(void) { |
351 | 0 | if ( !cryptofuzz_options->curves.Empty() ) { |
352 | 0 | return cryptofuzz_options->curves.At(PRNG()); |
353 | 0 | } else { |
354 | 0 | return ECC_CurveLUT[ PRNG() % (sizeof(ECC_CurveLUT) / sizeof(ECC_CurveLUT[0])) ].id; |
355 | 0 | } |
356 | 0 | } |
357 | | |
358 | 0 | static uint64_t getRandomCalcOp(void) { |
359 | 0 | if ( !cryptofuzz_options->calcOps.Empty() ) { |
360 | 0 | return cryptofuzz_options->calcOps.At(PRNG()); |
361 | 0 | } else { |
362 | 0 | return CalcOpLUT[ PRNG() % (sizeof(CalcOpLUT) / sizeof(CalcOpLUT[0])) ].id; |
363 | 0 | } |
364 | 0 | } |
365 | | |
366 | 0 | static std::string get_BLS_PyECC_DST(void) { |
367 | 0 | return "424c535f5349475f424c53313233383147325f584d443a5348412d3235365f535357555f524f5f504f505f"; |
368 | 0 | } |
369 | | |
370 | 0 | static std::string get_BLS_BasicScheme_DST(void) { |
371 | 0 | return "424c535f5349475f424c53313233383147325f584d443a5348412d3235365f535357555f524f5f4e554c5f"; |
372 | 0 | } |
373 | | |
374 | 0 | static std::string get_BLS_predefined_DST(void) { |
375 | 0 | return getBool() ? get_BLS_PyECC_DST() : get_BLS_BasicScheme_DST(); |
376 | 0 | } |
377 | | |
378 | 0 | static void generateECCPoint(void) { |
379 | 0 | if ( (PRNG() % 100) != 0 ) { |
380 | 0 | return; |
381 | 0 | } |
382 | | |
383 | 0 | const auto curveID = getRandomCurve(); |
384 | |
|
385 | 0 | const auto a = cryptofuzz::repository::ECC_CurveToA(curveID); |
386 | 0 | if ( a == std::nullopt ) { |
387 | 0 | return; |
388 | 0 | } |
389 | | |
390 | 0 | const auto b = cryptofuzz::repository::ECC_CurveToB(curveID); |
391 | 0 | if ( b == std::nullopt ) { |
392 | 0 | return; |
393 | 0 | } |
394 | | |
395 | 0 | const auto p = cryptofuzz::repository::ECC_CurveToPrime(curveID); |
396 | 0 | if ( p == std::nullopt ) { |
397 | 0 | return; |
398 | 0 | } |
399 | | |
400 | 0 | const auto o = cryptofuzz::repository::ECC_CurveToPrime(curveID); |
401 | 0 | if ( o == std::nullopt ) { |
402 | 0 | return; |
403 | 0 | } |
404 | | |
405 | 0 | const auto x = getBignum(true); |
406 | |
|
407 | 0 | const auto y = cryptofuzz::util::Find_ECC_Y(x, *a, *b, *p, *o, getBool()); |
408 | |
|
409 | 0 | if ( curveID == CF_ECC_CURVE("BLS12_381") || |
410 | 0 | curveID == CF_ECC_CURVE("alt_bn128") ) { |
411 | 0 | Pool_CurveBLSG1.Set({ curveID, x, y }); |
412 | 0 | } else { |
413 | 0 | Pool_CurveECC_Point.Set({ curveID, x, y }); |
414 | 0 | } |
415 | 0 | } |
416 | | |
417 | 0 | extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* data, size_t size, size_t maxSize, unsigned int seed) { |
418 | 0 | (void)seed; |
419 | 0 | std::vector<uint8_t> modifier; |
420 | 0 | bool reuseModifier; |
421 | |
|
422 | 0 | if ( maxSize < 64 || getBool() ) { |
423 | 0 | goto end; |
424 | 0 | } |
425 | | |
426 | 0 | reuseModifier = getBool(); |
427 | |
|
428 | 0 | if ( reuseModifier == true ) { |
429 | 0 | cryptofuzz::util::MemorySanitizerUnpoison(data, size); |
430 | | |
431 | | /* Try to extract modifier from input */ |
432 | 0 | try { |
433 | 0 | fuzzing::datasource::Datasource ds(data, size); |
434 | 0 | /* ignore result */ ds.Get<uint64_t>(); |
435 | 0 | /* ignore result */ ds.GetData(0, 1); |
436 | 0 | modifier = ds.GetData(0); |
437 | 0 | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } |
438 | 0 | } |
439 | |
|
440 | 0 | { |
441 | 0 | uint64_t operation; |
442 | |
|
443 | 0 | if ( !cryptofuzz_options->operations.Empty() ) { |
444 | 0 | operation = cryptofuzz_options->operations.At(PRNG()); |
445 | 0 | } else { |
446 | 0 | operation = OperationLUT[ PRNG() % (sizeof(OperationLUT) / sizeof(OperationLUT[0])) ].id; |
447 | 0 | } |
448 | |
|
449 | 0 | fuzzing::datasource::Datasource dsOut2(nullptr, 0); |
450 | |
|
451 | 0 | nlohmann::json parameters; |
452 | |
|
453 | 0 | #define GET_OR_BIGNUM(x) getBool() ? (x) : getBignum(); |
454 | 0 | switch ( operation ) { |
455 | 0 | case CF_OPERATION("Digest"): |
456 | 0 | { |
457 | 0 | parameters["modifier"] = ""; |
458 | 0 | parameters["cleartext"] = getBuffer(PRNG64() % maxSize); |
459 | 0 | parameters["digestType"] = getRandomDigest(); |
460 | |
|
461 | 0 | cryptofuzz::operation::Digest op(parameters); |
462 | 0 | op.Serialize(dsOut2); |
463 | 0 | } |
464 | 0 | break; |
465 | 0 | case CF_OPERATION("HMAC"): |
466 | 0 | { |
467 | 0 | size_t numParts = 0; |
468 | |
|
469 | 0 | numParts++; /* modifier */ |
470 | 0 | numParts++; /* cleartext */ |
471 | 0 | numParts++; /* iv */ |
472 | 0 | numParts++; /* key */ |
473 | |
|
474 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
475 | |
|
476 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
477 | 0 | parameters["cleartext"] = getBuffer(lengths[1]); |
478 | 0 | parameters["cipher"]["iv"] = getBuffer(lengths[2], true); |
479 | 0 | parameters["cipher"]["key"] = getBuffer(lengths[3], true); |
480 | 0 | parameters["cipher"]["cipherType"] = getRandomCipher(); |
481 | 0 | parameters["digestType"] = getRandomDigest(); |
482 | |
|
483 | 0 | cryptofuzz::operation::HMAC op(parameters); |
484 | 0 | op.Serialize(dsOut2); |
485 | 0 | } |
486 | 0 | break; |
487 | 0 | case CF_OPERATION("UMAC"): |
488 | 0 | { |
489 | 0 | parameters["modifier"] = ""; |
490 | 0 | parameters["cleartext"] = getBuffer(PRNG64() % maxSize); |
491 | 0 | parameters["key"] = getBuffer(16); |
492 | 0 | parameters["iv"] = getBuffer(PRNG() % 17); |
493 | 0 | parameters["type"] = PRNG() % 4; |
494 | 0 | parameters["outSize"] = PRNG() % 1024; |
495 | |
|
496 | 0 | cryptofuzz::operation::UMAC op(parameters); |
497 | 0 | op.Serialize(dsOut2); |
498 | 0 | } |
499 | 0 | break; |
500 | 0 | case CF_OPERATION("CMAC"): |
501 | 0 | { |
502 | 0 | size_t numParts = 0; |
503 | |
|
504 | 0 | numParts++; /* modifier */ |
505 | 0 | numParts++; /* cleartext */ |
506 | 0 | numParts++; /* iv */ |
507 | 0 | numParts++; /* key */ |
508 | |
|
509 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
510 | |
|
511 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
512 | 0 | parameters["cleartext"] = getBuffer(lengths[1]); |
513 | 0 | parameters["cipher"]["iv"] = getBuffer(lengths[2], true); |
514 | 0 | parameters["cipher"]["key"] = getBuffer(lengths[3], true); |
515 | 0 | parameters["cipher"]["cipherType"] = getRandomCipher(); |
516 | |
|
517 | 0 | cryptofuzz::operation::CMAC op(parameters); |
518 | 0 | op.Serialize(dsOut2); |
519 | 0 | } |
520 | 0 | break; |
521 | 0 | case CF_OPERATION("SymmetricEncrypt"): |
522 | 0 | { |
523 | 0 | const bool aad_enabled = PRNG() % 2; |
524 | 0 | const bool tagSize_enabled = PRNG() % 2; |
525 | 0 | size_t numParts = 0; |
526 | |
|
527 | 0 | numParts++; /* modifier */ |
528 | 0 | numParts++; /* cleartext */ |
529 | 0 | numParts++; /* iv */ |
530 | 0 | numParts++; /* key */ |
531 | |
|
532 | 0 | if ( aad_enabled ) { |
533 | 0 | numParts++; /* aad */ |
534 | 0 | } |
535 | |
|
536 | 0 | auto lengths = SplitLength(maxSize - 64, numParts); |
537 | |
|
538 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
539 | 0 | if ( getBool() ) { |
540 | 0 | if ( 16 < lengths[1] ) { |
541 | 0 | lengths[1] = 16; |
542 | 0 | } |
543 | 0 | } |
544 | 0 | parameters["cleartext"] = getBuffer(lengths[1]); |
545 | |
|
546 | 0 | parameters["cipher"]["iv"] = getBuffer(lengths[2], true); |
547 | 0 | parameters["cipher"]["key"] = getBuffer(lengths[3], true); |
548 | |
|
549 | 0 | if ( aad_enabled ) { |
550 | 0 | parameters["aad_enabled"] = true; |
551 | 0 | if ( getBool() ) { |
552 | 0 | lengths[4] = 0; |
553 | 0 | } |
554 | 0 | parameters["aad"] = getBuffer(lengths[4]); |
555 | 0 | } else { |
556 | 0 | parameters["aad_enabled"] = false; |
557 | 0 | } |
558 | |
|
559 | 0 | if ( tagSize_enabled ) { |
560 | 0 | parameters["tagSize_enabled"] = true; |
561 | 0 | if ( getBool() ) { |
562 | 0 | parameters["tagSize"] = getDefaultSize(); |
563 | 0 | } else { |
564 | 0 | parameters["tagSize"] = PRNG() % 102400; |
565 | 0 | } |
566 | 0 | } else { |
567 | 0 | parameters["tagSize_enabled"] = false; |
568 | 0 | } |
569 | |
|
570 | 0 | parameters["cipher"]["cipherType"] = getRandomCipher(); |
571 | 0 | parameters["ciphertextSize"] = PRNG() % (lengths[1] + 9); |
572 | |
|
573 | 0 | cryptofuzz::operation::SymmetricEncrypt op(parameters); |
574 | 0 | op.Serialize(dsOut2); |
575 | 0 | } |
576 | 0 | break; |
577 | 0 | case CF_OPERATION("SymmetricDecrypt"): |
578 | 0 | { |
579 | 0 | const bool aad_enabled = PRNG() % 2; |
580 | 0 | const bool tag_enabled = PRNG() % 2; |
581 | 0 | size_t numParts = 0; |
582 | |
|
583 | 0 | numParts++; /* modifier */ |
584 | 0 | numParts++; /* cleartext */ |
585 | 0 | numParts++; /* iv */ |
586 | 0 | numParts++; /* key */ |
587 | |
|
588 | 0 | if ( aad_enabled ) { |
589 | 0 | numParts++; /* aad */ |
590 | 0 | } |
591 | 0 | if ( tag_enabled ) { |
592 | 0 | numParts++; /* tag */ |
593 | 0 | } |
594 | |
|
595 | 0 | auto lengths = SplitLength(maxSize - 64, numParts); |
596 | |
|
597 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
598 | 0 | if ( getBool() ) { |
599 | 0 | if ( 16 < lengths[1] ) { |
600 | 0 | lengths[1] = 16; |
601 | 0 | } |
602 | 0 | } |
603 | 0 | parameters["ciphertext"] = getBuffer(lengths[1]); |
604 | |
|
605 | 0 | parameters["cipher"]["iv"] = getBuffer(lengths[2], true); |
606 | 0 | parameters["cipher"]["key"] = getBuffer(lengths[3], true); |
607 | |
|
608 | 0 | if ( aad_enabled ) { |
609 | 0 | parameters["aad_enabled"] = true; |
610 | 0 | if ( getBool() ) { |
611 | 0 | lengths[4] = 0; |
612 | 0 | } |
613 | 0 | parameters["aad"] = getBuffer(lengths[4]); |
614 | 0 | } else { |
615 | 0 | parameters["aad_enabled"] = false; |
616 | 0 | } |
617 | |
|
618 | 0 | if ( tag_enabled ) { |
619 | 0 | parameters["tag_enabled"] = true; |
620 | 0 | parameters["tag"] = getBuffer(lengths[aad_enabled ? 5 : 4], true); |
621 | 0 | } else { |
622 | 0 | parameters["tag_enabled"] = false; |
623 | 0 | } |
624 | |
|
625 | 0 | parameters["cipher"]["cipherType"] = getRandomCipher(); |
626 | 0 | parameters["cleartextSize"] = PRNG() % (lengths[1] + 9); |
627 | |
|
628 | 0 | cryptofuzz::operation::SymmetricDecrypt op(parameters); |
629 | 0 | op.Serialize(dsOut2); |
630 | 0 | } |
631 | 0 | break; |
632 | 0 | case CF_OPERATION("BignumCalc"): |
633 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_381_R"): |
634 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_381_P"): |
635 | 0 | case CF_OPERATION("BignumCalc_Mod_BN128_R"): |
636 | 0 | case CF_OPERATION("BignumCalc_Mod_BN128_P"): |
637 | 0 | case CF_OPERATION("BignumCalc_Mod_ED25519"): |
638 | 0 | case CF_OPERATION("BignumCalc_Mod_Edwards_R"): |
639 | 0 | case CF_OPERATION("BignumCalc_Mod_Edwards_P"): |
640 | 0 | case CF_OPERATION("BignumCalc_Mod_MNT4_R"): |
641 | 0 | case CF_OPERATION("BignumCalc_Mod_MNT4_P"): |
642 | 0 | case CF_OPERATION("BignumCalc_Mod_MNT6_R"): |
643 | 0 | case CF_OPERATION("BignumCalc_Mod_MNT6_P"): |
644 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp64"): |
645 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp128"): |
646 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp256"): |
647 | 0 | case CF_OPERATION("BignumCalc_Mod_2Exp512"): |
648 | 0 | case CF_OPERATION("BignumCalc_Mod_SECP256K1"): |
649 | 0 | case CF_OPERATION("BignumCalc_Mod_SECP256K1_P"): |
650 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_377_R"): |
651 | 0 | case CF_OPERATION("BignumCalc_Mod_BLS12_377_P"): |
652 | 0 | { |
653 | 0 | parameters["modifier"] = ""; |
654 | |
|
655 | 0 | const auto calcop = getRandomCalcOp(); |
656 | 0 | parameters["calcOp"] = calcop; |
657 | |
|
658 | 0 | auto bn1 = getBignum(); |
659 | 0 | const auto bn2 = getBignum(); |
660 | 0 | const auto bn3 = getBignum(); |
661 | |
|
662 | 0 | if ( calcop == CF_CALCOP("InvMod(A,B)") || calcop == CF_CALCOP("ExpMod(A,B,C)") ) { |
663 | 0 | std::optional<std::string> mod = get_op_mod(operation); |
664 | |
|
665 | 0 | if ( mod == std::nullopt ) { |
666 | 0 | if ( calcop == CF_CALCOP("InvMod(A,B)") ) { |
667 | 0 | mod = bn2; |
668 | 0 | } else if ( CF_CALCOP("ExpMod(A,B,C)") ) { |
669 | 0 | mod = bn3; |
670 | 0 | } else { |
671 | 0 | abort(); |
672 | 0 | } |
673 | 0 | } |
674 | | |
675 | 0 | const auto mont = from_mont(mutateBinary(getBignum()), *mod); |
676 | 0 | Pool_Bignum.Set(mont); |
677 | |
|
678 | 0 | if ( getBool() ) { |
679 | 0 | bn1 = mont; |
680 | 0 | } |
681 | 0 | } |
682 | | |
683 | 0 | parameters["bn1"] = bn1; |
684 | 0 | parameters["bn2"] = bn2; |
685 | 0 | parameters["bn3"] = bn3; |
686 | 0 | parameters["bn4"] = ""; |
687 | |
|
688 | 0 | if ( calcop == CF_CALCOP("ExpMod(A,B,C)") && operation == CF_OPERATION("BignumCalc") ) { |
689 | 0 | if ( PRNG() % 100 == 0 ) { |
690 | 0 | const auto p = cryptofuzz::mutator::ExpModGenerator::generate_exp_mod(getBignum(true)); |
691 | |
|
692 | 0 | if ( p != std::nullopt ) { |
693 | 0 | parameters = *p; |
694 | 0 | } |
695 | 0 | } |
696 | 0 | } |
697 | | #if defined(CRYPTOFUZZ_HAVE_Z3) |
698 | | else if ( (PRNG() % 1000) == 0 ) { |
699 | | const auto p = cryptofuzz::Z3::Generate(calcop); |
700 | | if ( p != std::nullopt ) { |
701 | | parameters = *p; |
702 | | } |
703 | | } |
704 | | #endif |
705 | 0 | cryptofuzz::operation::BignumCalc op(parameters); |
706 | 0 | op.Serialize(dsOut2); |
707 | 0 | } |
708 | 0 | break; |
709 | 0 | case CF_OPERATION("BignumCalc_Fp2"): |
710 | 0 | { |
711 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
712 | 0 | parameters["calcOp"] = getRandomCalcOp(); |
713 | 0 | parameters["bn1"][0] = getBignum(); |
714 | 0 | parameters["bn1"][1] = getBignum(); |
715 | 0 | parameters["bn2"][0] = getBignum(); |
716 | 0 | parameters["bn2"][1] = getBignum(); |
717 | 0 | parameters["bn3"][0] = ""; |
718 | 0 | parameters["bn3"][1] = ""; |
719 | 0 | parameters["bn4"][0] = ""; |
720 | 0 | parameters["bn4"][1] = ""; |
721 | |
|
722 | 0 | cryptofuzz::operation::BignumCalc_Fp2 op(parameters); |
723 | 0 | op.Serialize(dsOut2); |
724 | 0 | } |
725 | 0 | break; |
726 | | |
727 | 0 | case CF_OPERATION("BignumCalc_Fp12"): |
728 | 0 | { |
729 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
730 | 0 | parameters["calcOp"] = getRandomCalcOp(); |
731 | |
|
732 | 0 | if ( Pool_Fp12.Have() && getBool() == true ) { |
733 | 0 | const auto Fp12 = Pool_Fp12.Get(); |
734 | | #if 0 |
735 | | parameters["bn1"][0] = GET_OR_BIGNUM(Fp12.bn1); |
736 | | parameters["bn1"][1] = GET_OR_BIGNUM(Fp12.bn2); |
737 | | parameters["bn1"][2] = GET_OR_BIGNUM(Fp12.bn3); |
738 | | parameters["bn1"][3] = GET_OR_BIGNUM(Fp12.bn4); |
739 | | parameters["bn1"][4] = GET_OR_BIGNUM(Fp12.bn5); |
740 | | parameters["bn1"][5] = GET_OR_BIGNUM(Fp12.bn6); |
741 | | parameters["bn1"][6] = GET_OR_BIGNUM(Fp12.bn7); |
742 | | parameters["bn1"][7] = GET_OR_BIGNUM(Fp12.bn8); |
743 | | parameters["bn1"][8] = GET_OR_BIGNUM(Fp12.bn9); |
744 | | parameters["bn1"][9] = GET_OR_BIGNUM(Fp12.bn10); |
745 | | parameters["bn1"][10] = GET_OR_BIGNUM(Fp12.bn11); |
746 | | parameters["bn1"][11] = GET_OR_BIGNUM(Fp12.bn12); |
747 | | #endif |
748 | 0 | parameters["bn1"][0] = Fp12.bn1; |
749 | 0 | parameters["bn1"][1] = Fp12.bn2; |
750 | 0 | parameters["bn1"][2] = Fp12.bn3; |
751 | 0 | parameters["bn1"][3] = Fp12.bn4; |
752 | 0 | parameters["bn1"][4] = Fp12.bn5; |
753 | 0 | parameters["bn1"][5] = Fp12.bn6; |
754 | 0 | parameters["bn1"][6] = Fp12.bn7; |
755 | 0 | parameters["bn1"][7] = Fp12.bn8; |
756 | 0 | parameters["bn1"][8] = Fp12.bn9; |
757 | 0 | parameters["bn1"][9] = Fp12.bn10; |
758 | 0 | parameters["bn1"][10] = Fp12.bn11; |
759 | 0 | parameters["bn1"][11] = Fp12.bn12; |
760 | 0 | } else { |
761 | 0 | parameters["bn1"][0] = getBignum(); |
762 | 0 | parameters["bn1"][1] = getBignum(); |
763 | 0 | parameters["bn1"][2] = getBignum(); |
764 | 0 | parameters["bn1"][3] = getBignum(); |
765 | 0 | parameters["bn1"][4] = getBignum(); |
766 | 0 | parameters["bn1"][5] = getBignum(); |
767 | 0 | parameters["bn1"][6] = getBignum(); |
768 | 0 | parameters["bn1"][7] = getBignum(); |
769 | 0 | parameters["bn1"][8] = getBignum(); |
770 | 0 | parameters["bn1"][9] = getBignum(); |
771 | 0 | parameters["bn1"][10] = getBignum(); |
772 | 0 | parameters["bn1"][11] = getBignum(); |
773 | |
|
774 | 0 | parameters["bn2"][0] = getBignum(); |
775 | 0 | parameters["bn2"][1] = getBignum(); |
776 | 0 | parameters["bn2"][2] = getBignum(); |
777 | 0 | parameters["bn2"][3] = getBignum(); |
778 | 0 | parameters["bn2"][4] = getBignum(); |
779 | 0 | parameters["bn2"][5] = getBignum(); |
780 | 0 | parameters["bn2"][6] = getBignum(); |
781 | 0 | parameters["bn2"][7] = getBignum(); |
782 | 0 | parameters["bn2"][8] = getBignum(); |
783 | 0 | parameters["bn2"][9] = getBignum(); |
784 | 0 | parameters["bn2"][10] = getBignum(); |
785 | 0 | parameters["bn2"][11] = getBignum(); |
786 | 0 | } |
787 | |
|
788 | 0 | if ( Pool_Fp12.Have() && getBool() == true ) { |
789 | 0 | const auto Fp12 = Pool_Fp12.Get(); |
790 | | #if 0 |
791 | | parameters["bn2"][0] = GET_OR_BIGNUM(Fp12.bn1); |
792 | | parameters["bn2"][1] = GET_OR_BIGNUM(Fp12.bn2); |
793 | | parameters["bn2"][2] = GET_OR_BIGNUM(Fp12.bn3); |
794 | | parameters["bn2"][3] = GET_OR_BIGNUM(Fp12.bn4); |
795 | | parameters["bn2"][4] = GET_OR_BIGNUM(Fp12.bn5); |
796 | | parameters["bn2"][5] = GET_OR_BIGNUM(Fp12.bn6); |
797 | | parameters["bn2"][6] = GET_OR_BIGNUM(Fp12.bn7); |
798 | | parameters["bn2"][7] = GET_OR_BIGNUM(Fp12.bn8); |
799 | | parameters["bn2"][8] = GET_OR_BIGNUM(Fp12.bn9); |
800 | | parameters["bn2"][9] = GET_OR_BIGNUM(Fp12.bn10); |
801 | | parameters["bn2"][10] = GET_OR_BIGNUM(Fp12.bn11); |
802 | | parameters["bn2"][11] = GET_OR_BIGNUM(Fp12.bn12); |
803 | | #endif |
804 | 0 | parameters["bn2"][0] = Fp12.bn1; |
805 | 0 | parameters["bn2"][1] = Fp12.bn2; |
806 | 0 | parameters["bn2"][2] = Fp12.bn3; |
807 | 0 | parameters["bn2"][3] = Fp12.bn4; |
808 | 0 | parameters["bn2"][4] = Fp12.bn5; |
809 | 0 | parameters["bn2"][5] = Fp12.bn6; |
810 | 0 | parameters["bn2"][6] = Fp12.bn7; |
811 | 0 | parameters["bn2"][7] = Fp12.bn8; |
812 | 0 | parameters["bn2"][8] = Fp12.bn9; |
813 | 0 | parameters["bn2"][9] = Fp12.bn10; |
814 | 0 | parameters["bn2"][10] = Fp12.bn11; |
815 | 0 | parameters["bn2"][11] = Fp12.bn12; |
816 | 0 | } else { |
817 | 0 | parameters["bn2"][0] = getBignum(); |
818 | 0 | parameters["bn2"][1] = getBignum(); |
819 | 0 | parameters["bn2"][2] = getBignum(); |
820 | 0 | parameters["bn2"][3] = getBignum(); |
821 | 0 | parameters["bn2"][4] = getBignum(); |
822 | 0 | parameters["bn2"][5] = getBignum(); |
823 | 0 | parameters["bn2"][6] = getBignum(); |
824 | 0 | parameters["bn2"][7] = getBignum(); |
825 | 0 | parameters["bn2"][8] = getBignum(); |
826 | 0 | parameters["bn2"][9] = getBignum(); |
827 | 0 | parameters["bn2"][10] = getBignum(); |
828 | 0 | parameters["bn2"][11] = getBignum(); |
829 | 0 | } |
830 | |
|
831 | 0 | parameters["bn3"][0] = ""; |
832 | 0 | parameters["bn3"][1] = ""; |
833 | 0 | parameters["bn3"][2] = ""; |
834 | 0 | parameters["bn3"][3] = ""; |
835 | 0 | parameters["bn3"][4] = ""; |
836 | 0 | parameters["bn3"][5] = ""; |
837 | 0 | parameters["bn3"][6] = ""; |
838 | 0 | parameters["bn3"][7] = ""; |
839 | 0 | parameters["bn3"][8] = ""; |
840 | 0 | parameters["bn3"][9] = ""; |
841 | 0 | parameters["bn3"][10] = ""; |
842 | 0 | parameters["bn3"][11] = ""; |
843 | |
|
844 | 0 | parameters["bn4"][0] = ""; |
845 | 0 | parameters["bn4"][1] = ""; |
846 | 0 | parameters["bn4"][2] = ""; |
847 | 0 | parameters["bn4"][3] = ""; |
848 | 0 | parameters["bn4"][4] = ""; |
849 | 0 | parameters["bn4"][5] = ""; |
850 | 0 | parameters["bn4"][6] = ""; |
851 | 0 | parameters["bn4"][7] = ""; |
852 | 0 | parameters["bn4"][8] = ""; |
853 | 0 | parameters["bn4"][9] = ""; |
854 | 0 | parameters["bn4"][10] = ""; |
855 | 0 | parameters["bn4"][11] = ""; |
856 | 0 | cryptofuzz::operation::BignumCalc_Fp12 op(parameters); |
857 | 0 | op.Serialize(dsOut2); |
858 | 0 | } |
859 | 0 | break; |
860 | 0 | case CF_OPERATION("ECC_PrivateToPublic"): |
861 | 0 | { |
862 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
863 | |
|
864 | 0 | if ( Pool_CurvePrivkey.Have() && getBool() == true ) { |
865 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
866 | |
|
867 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
868 | 0 | parameters["priv"] = P1.priv; |
869 | 0 | } else { |
870 | 0 | const auto curveID = getRandomCurve(); |
871 | 0 | parameters["curveType"] = hint_ecc_mont(curveID); |
872 | |
|
873 | 0 | if ( getBool() ) { |
874 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(curveID); |
875 | 0 | if ( order != std::nullopt ) { |
876 | 0 | const auto o = boost::multiprecision::cpp_int(*order); |
877 | 0 | parameters["priv"] = boost::lexical_cast<std::string>(o-1); |
878 | 0 | } else { |
879 | 0 | parameters["priv"] = getBignum(); |
880 | 0 | } |
881 | 0 | } else { |
882 | 0 | parameters["priv"] = getBignum(); |
883 | 0 | } |
884 | |
|
885 | 0 | } |
886 | |
|
887 | 0 | cryptofuzz::operation::ECC_PrivateToPublic op(parameters); |
888 | 0 | op.Serialize(dsOut2); |
889 | 0 | } |
890 | 0 | break; |
891 | 0 | case CF_OPERATION("ECC_ValidatePubkey"): |
892 | 0 | { |
893 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
894 | |
|
895 | 0 | if ( getBool() && Pool_CurveKeypair.Have() ) { |
896 | 0 | const auto P = Pool_CurveKeypair.Get(); |
897 | |
|
898 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
899 | |
|
900 | 0 | parameters["pub_x"] = getBool() ? getBignum() : P.pub_x; |
901 | 0 | parameters["pub_y"] = getBool() ? getBignum() : P.pub_y; |
902 | 0 | } else if ( getBool() && Pool_CurveECC_Point.Have() == true ) { |
903 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
904 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
905 | |
|
906 | 0 | parameters["pub_x"] = getBool() ? getBignum() : P.x; |
907 | 0 | parameters["pub_y"] = getBool() ? getBignum() : P.y; |
908 | 0 | } else { |
909 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
910 | 0 | parameters["pub_x"] = getBignum(); |
911 | 0 | parameters["pub_y"] = getBignum(); |
912 | 0 | } |
913 | |
|
914 | 0 | cryptofuzz::operation::ECC_ValidatePubkey op(parameters); |
915 | 0 | op.Serialize(dsOut2); |
916 | |
|
917 | 0 | generateECCPoint(); |
918 | 0 | } |
919 | 0 | break; |
920 | 0 | case CF_OPERATION("DSA_GenerateParameters"): |
921 | 0 | { |
922 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
923 | 0 | cryptofuzz::operation::DSA_GenerateParameters op(parameters); |
924 | 0 | op.Serialize(dsOut2); |
925 | 0 | } |
926 | 0 | break; |
927 | 0 | case CF_OPERATION("DSA_PrivateToPublic"): |
928 | 0 | { |
929 | 0 | parameters["modifier"] = ""; |
930 | |
|
931 | 0 | if ( Pool_DSA_PQG.Have() && getBool() == true ) { |
932 | 0 | const auto PQG = Pool_DSA_PQG.Get(); |
933 | 0 | parameters["p"] = PQG.p; |
934 | 0 | parameters["g"] = PQG.g; |
935 | 0 | } else { |
936 | 0 | parameters["p"] = getBignum(); |
937 | 0 | parameters["g"] = getBignum(); |
938 | 0 | } |
939 | |
|
940 | 0 | parameters["priv"] = getBignum(); |
941 | |
|
942 | 0 | cryptofuzz::operation::DSA_PrivateToPublic op(parameters); |
943 | 0 | op.Serialize(dsOut2); |
944 | 0 | } |
945 | 0 | break; |
946 | 0 | case CF_OPERATION("DSA_GenerateKeyPair"): |
947 | 0 | { |
948 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
949 | |
|
950 | 0 | if ( Pool_DSA_PQG.Have() && getBool() == true ) { |
951 | 0 | const auto PQG = Pool_DSA_PQG.Get(); |
952 | 0 | parameters["p"] = PQG.p; |
953 | 0 | parameters["q"] = PQG.q; |
954 | 0 | parameters["g"] = PQG.g; |
955 | 0 | } else { |
956 | 0 | parameters["p"] = getBignum(); |
957 | 0 | parameters["q"] = getBignum(); |
958 | 0 | parameters["g"] = getBignum(); |
959 | 0 | } |
960 | |
|
961 | 0 | cryptofuzz::operation::DSA_GenerateKeyPair op(parameters); |
962 | 0 | op.Serialize(dsOut2); |
963 | 0 | } |
964 | 0 | break; |
965 | 0 | case CF_OPERATION("DSA_Verify"): |
966 | 0 | { |
967 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
968 | |
|
969 | 0 | if ( Pool_DSASignature.Have() && getBool() == true ) { |
970 | 0 | const auto sig = Pool_DSASignature.Get(); |
971 | |
|
972 | 0 | nlohmann::json parameters_; |
973 | 0 | parameters_["p"] = sig.p; |
974 | 0 | parameters_["q"] = sig.q; |
975 | 0 | parameters_["g"] = sig.g; |
976 | |
|
977 | 0 | parameters["parameters"] = parameters_; |
978 | |
|
979 | 0 | parameters["signature"][0] = getBool() ? getBignum() : sig.r; |
980 | 0 | parameters["signature"][1] = getBool() ? getBignum() : sig.s; |
981 | 0 | parameters["pub"] = sig.pub; |
982 | 0 | parameters["cleartext"] = sig.cleartext; |
983 | 0 | } else { |
984 | 0 | nlohmann::json parameters_; |
985 | 0 | parameters_["p"] = getBignum(); |
986 | 0 | parameters_["q"] = getBignum(); |
987 | 0 | parameters_["g"] = getBignum(); |
988 | |
|
989 | 0 | parameters["parameters"] = parameters_; |
990 | |
|
991 | 0 | parameters["signature"][0] = getBignum(); |
992 | 0 | parameters["signature"][1] = getBignum(); |
993 | 0 | parameters["pub"] = getBignum(); |
994 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 8); |
995 | 0 | } |
996 | | |
997 | |
|
998 | 0 | cryptofuzz::operation::DSA_Verify op(parameters); |
999 | 0 | op.Serialize(dsOut2); |
1000 | 0 | } |
1001 | 0 | break; |
1002 | 0 | case CF_OPERATION("DSA_Sign"): |
1003 | 0 | { |
1004 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1005 | |
|
1006 | 0 | if ( Pool_DSA_PQG.Have() && getBool() == true ) { |
1007 | 0 | const auto PQG = Pool_DSA_PQG.Get(); |
1008 | |
|
1009 | 0 | nlohmann::json parameters_; |
1010 | 0 | parameters_["p"] = PQG.p; |
1011 | 0 | parameters_["q"] = PQG.q; |
1012 | 0 | parameters_["g"] = PQG.g; |
1013 | |
|
1014 | 0 | parameters["parameters"] = parameters_; |
1015 | 0 | } else { |
1016 | 0 | nlohmann::json parameters_; |
1017 | 0 | parameters_["p"] = getBignum(); |
1018 | 0 | parameters_["q"] = getBignum(); |
1019 | 0 | parameters_["g"] = getBignum(); |
1020 | |
|
1021 | 0 | parameters["parameters"] = parameters_; |
1022 | 0 | } |
1023 | |
|
1024 | 0 | parameters["priv"] = getBignum(); |
1025 | |
|
1026 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 8); |
1027 | |
|
1028 | 0 | cryptofuzz::operation::DSA_Sign op(parameters); |
1029 | 0 | op.Serialize(dsOut2); |
1030 | 0 | } |
1031 | 0 | break; |
1032 | 0 | case CF_OPERATION("ECDH_Derive"): |
1033 | 0 | { |
1034 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1035 | |
|
1036 | 0 | if ( Pool_CurvePrivkey.Have() && getBool() == true ) { |
1037 | 0 | const auto P1 = Pool_CurveKeypair.Get(); |
1038 | 0 | const auto P2 = Pool_CurveKeypair.Get(); |
1039 | |
|
1040 | 0 | CF_CHECK_EQ(P1.curveID, P2.curveID); |
1041 | |
|
1042 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1043 | |
|
1044 | 0 | parameters["priv"] = P1.privkey; |
1045 | |
|
1046 | 0 | parameters["pub_x"] = P1.pub_x; |
1047 | 0 | parameters["pub_y"] = P1.pub_y; |
1048 | 0 | } else { |
1049 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1050 | |
|
1051 | 0 | parameters["priv"] = getBignum(); |
1052 | |
|
1053 | 0 | parameters["pub_x"] = getBignum(); |
1054 | 0 | parameters["pub_y"] = getBignum(); |
1055 | 0 | } |
1056 | | |
1057 | 0 | cryptofuzz::operation::ECDH_Derive op(parameters); |
1058 | 0 | op.Serialize(dsOut2); |
1059 | 0 | } |
1060 | 0 | break; |
1061 | 0 | case CF_OPERATION("ECCSI_Sign"): |
1062 | 0 | { |
1063 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1064 | |
|
1065 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
1066 | |
|
1067 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1068 | 0 | parameters["priv"] = P1.priv; |
1069 | |
|
1070 | 0 | if ( getBool() ) { |
1071 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1072 | 0 | } else { |
1073 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1074 | 0 | } |
1075 | 0 | parameters["digestType"] = getRandomDigest(); |
1076 | 0 | parameters["id"] = getBuffer(PRNG() % 1024); |
1077 | |
|
1078 | 0 | cryptofuzz::operation::ECCSI_Sign op(parameters); |
1079 | 0 | op.Serialize(dsOut2); |
1080 | 0 | } |
1081 | 0 | break; |
1082 | 0 | case CF_OPERATION("ECDSA_Sign"): |
1083 | 0 | { |
1084 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1085 | |
|
1086 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
1087 | |
|
1088 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1089 | 0 | parameters["priv"] = P1.priv; |
1090 | 0 | parameters["nonce"] = getBignum(); |
1091 | |
|
1092 | 0 | if ( getBool() ) { |
1093 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1094 | 0 | } else { |
1095 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1096 | 0 | } |
1097 | 0 | parameters["nonceSource"] = PRNG() % 3; |
1098 | 0 | parameters["digestType"] = getRandomDigest(); |
1099 | |
|
1100 | 0 | cryptofuzz::operation::ECDSA_Sign op(parameters); |
1101 | 0 | op.Serialize(dsOut2); |
1102 | 0 | } |
1103 | 0 | break; |
1104 | 0 | case CF_OPERATION("ECGDSA_Sign"): |
1105 | 0 | { |
1106 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1107 | |
|
1108 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
1109 | |
|
1110 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1111 | 0 | parameters["priv"] = P1.priv; |
1112 | 0 | parameters["nonce"] = getBignum(); |
1113 | |
|
1114 | 0 | if ( getBool() ) { |
1115 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1116 | 0 | } else { |
1117 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1118 | 0 | } |
1119 | 0 | parameters["nonceSource"] = PRNG() % 3; |
1120 | 0 | parameters["digestType"] = getRandomDigest(); |
1121 | |
|
1122 | 0 | cryptofuzz::operation::ECGDSA_Sign op(parameters); |
1123 | 0 | op.Serialize(dsOut2); |
1124 | 0 | } |
1125 | 0 | break; |
1126 | 0 | case CF_OPERATION("ECRDSA_Sign"): |
1127 | 0 | { |
1128 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1129 | |
|
1130 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
1131 | |
|
1132 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1133 | 0 | parameters["priv"] = P1.priv; |
1134 | 0 | parameters["nonce"] = getBignum(); |
1135 | |
|
1136 | 0 | if ( getBool() ) { |
1137 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1138 | 0 | } else { |
1139 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1140 | 0 | } |
1141 | 0 | parameters["nonceSource"] = PRNG() % 3; |
1142 | 0 | parameters["digestType"] = getRandomDigest(); |
1143 | |
|
1144 | 0 | cryptofuzz::operation::ECRDSA_Sign op(parameters); |
1145 | 0 | op.Serialize(dsOut2); |
1146 | 0 | } |
1147 | 0 | break; |
1148 | 0 | case CF_OPERATION("Schnorr_Sign"): |
1149 | 0 | { |
1150 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1151 | |
|
1152 | 0 | const auto P1 = Pool_CurvePrivkey.Get(); |
1153 | |
|
1154 | 0 | parameters["curveType"] = hint_ecc_mont(P1.curveID); |
1155 | 0 | parameters["priv"] = P1.priv; |
1156 | 0 | parameters["nonce"] = getBignum(); |
1157 | |
|
1158 | 0 | if ( getBool() ) { |
1159 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1160 | 0 | } else { |
1161 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1162 | 0 | } |
1163 | 0 | parameters["nonceSource"] = PRNG() % 3; |
1164 | 0 | parameters["digestType"] = getRandomDigest(); |
1165 | |
|
1166 | 0 | cryptofuzz::operation::Schnorr_Sign op(parameters); |
1167 | 0 | op.Serialize(dsOut2); |
1168 | 0 | } |
1169 | 0 | break; |
1170 | 0 | case CF_OPERATION("ECCSI_Verify"): |
1171 | 0 | { |
1172 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1173 | |
|
1174 | 0 | if ( Pool_CurveECCSISignature.Have() == true ) { |
1175 | 0 | const auto P = Pool_CurveECCSISignature.Get(); |
1176 | | #if 0 |
1177 | | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1178 | | |
1179 | | parameters["signature"]["pub"][0] = getBool() ? getBignum() : P.pub_x; |
1180 | | parameters["signature"]["pub"][1] = getBool() ? getBignum() : P.pub_y; |
1181 | | |
1182 | | parameters["signature"]["pvt"][0] = getBool() ? getBignum() : P.pvt_x; |
1183 | | parameters["signature"]["pvt"][1] = getBool() ? getBignum() : P.pvt_y; |
1184 | | |
1185 | | parameters["signature"]["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1186 | | parameters["signature"]["signature"][1] = getBool() ? getBignum() : P.sig_s; |
1187 | | |
1188 | | parameters["cleartext"] = P.cleartext; |
1189 | | parameters["id"] = P.id; |
1190 | | #endif |
1191 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1192 | |
|
1193 | 0 | parameters["signature"]["pub"][0] = P.pub_x; |
1194 | 0 | parameters["signature"]["pub"][1] = P.pub_y; |
1195 | |
|
1196 | 0 | parameters["signature"]["pvt"][0] = P.pvt_x; |
1197 | 0 | parameters["signature"]["pvt"][1] = P.pvt_y; |
1198 | |
|
1199 | 0 | parameters["signature"]["signature"][0] = P.sig_r; |
1200 | 0 | parameters["signature"]["signature"][1] = P.sig_s; |
1201 | |
|
1202 | 0 | parameters["cleartext"] = P.cleartext; |
1203 | 0 | parameters["id"] = P.id; |
1204 | 0 | } else { |
1205 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1206 | |
|
1207 | 0 | parameters["signature"]["pub"][0] = getBignum(); |
1208 | 0 | parameters["signature"]["pub"][1] = getBignum(); |
1209 | |
|
1210 | 0 | parameters["signature"]["pvt"][0] = getBignum(); |
1211 | 0 | parameters["signature"]["pvt"][1] = getBignum(); |
1212 | |
|
1213 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
1214 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
1215 | |
|
1216 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1217 | 0 | parameters["id"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1218 | 0 | } |
1219 | |
|
1220 | 0 | parameters["digestType"] = getRandomDigest(); |
1221 | |
|
1222 | 0 | cryptofuzz::operation::ECCSI_Verify op(parameters); |
1223 | 0 | op.Serialize(dsOut2); |
1224 | 0 | } |
1225 | 0 | break; |
1226 | 0 | case CF_OPERATION("ECDSA_Verify"): |
1227 | 0 | { |
1228 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1229 | |
|
1230 | 0 | if ( Pool_CurveECDSASignature.Have() == true ) { |
1231 | 0 | const auto P = Pool_CurveECDSASignature.Get(); |
1232 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1233 | |
|
1234 | 0 | parameters["signature"]["pub"][0] = getBool() ? getBignum() : P.pub_x; |
1235 | 0 | parameters["signature"]["pub"][1] = getBool() ? getBignum() : P.pub_y; |
1236 | |
|
1237 | 0 | parameters["signature"]["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1238 | 0 | auto sigS = getBool() ? getBignum() : P.sig_y; |
1239 | |
|
1240 | 0 | if ( getBool() ) { |
1241 | | /* Test ECDSA signature malleability */ |
1242 | |
|
1243 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(P.curveID); |
1244 | 0 | if ( order != std::nullopt ) { |
1245 | 0 | const auto o = boost::multiprecision::cpp_int(*order); |
1246 | 0 | const auto s = boost::multiprecision::cpp_int(sigS); |
1247 | 0 | if ( o > s ) { |
1248 | 0 | sigS = boost::lexical_cast<std::string>(o - s); |
1249 | 0 | } |
1250 | 0 | } |
1251 | 0 | } |
1252 | |
|
1253 | 0 | parameters["signature"]["signature"][1] = sigS; |
1254 | 0 | parameters["cleartext"] = P.cleartext; |
1255 | 0 | } else { |
1256 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1257 | |
|
1258 | 0 | parameters["signature"]["pub"][0] = getBignum(); |
1259 | 0 | parameters["signature"]["pub"][1] = getBignum(); |
1260 | |
|
1261 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
1262 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
1263 | |
|
1264 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1265 | 0 | } |
1266 | |
|
1267 | 0 | parameters["digestType"] = getRandomDigest(); |
1268 | |
|
1269 | 0 | cryptofuzz::operation::ECDSA_Verify op(parameters); |
1270 | 0 | op.Serialize(dsOut2); |
1271 | 0 | } |
1272 | 0 | break; |
1273 | 0 | case CF_OPERATION("ECGDSA_Verify"): |
1274 | 0 | { |
1275 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1276 | |
|
1277 | 0 | if ( Pool_CurveECDSASignature.Have() == true ) { |
1278 | 0 | const auto P = Pool_CurveECDSASignature.Get(); |
1279 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1280 | |
|
1281 | 0 | parameters["signature"]["pub"][0] = getBool() ? getBignum() : P.pub_x; |
1282 | 0 | parameters["signature"]["pub"][1] = getBool() ? getBignum() : P.pub_y; |
1283 | |
|
1284 | 0 | parameters["signature"]["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1285 | 0 | auto sigS = getBool() ? getBignum() : P.sig_y; |
1286 | |
|
1287 | 0 | if ( getBool() ) { |
1288 | | /* Test ECGDSA signature malleability */ |
1289 | |
|
1290 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(P.curveID); |
1291 | 0 | if ( order != std::nullopt ) { |
1292 | 0 | const auto o = boost::multiprecision::cpp_int(*order); |
1293 | 0 | const auto s = boost::multiprecision::cpp_int(sigS); |
1294 | 0 | if ( o > s ) { |
1295 | 0 | sigS = boost::lexical_cast<std::string>(o - s); |
1296 | 0 | } |
1297 | 0 | } |
1298 | 0 | } |
1299 | |
|
1300 | 0 | parameters["signature"]["signature"][1] = sigS; |
1301 | 0 | parameters["cleartext"] = P.cleartext; |
1302 | 0 | } else { |
1303 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1304 | |
|
1305 | 0 | parameters["signature"]["pub"][0] = getBignum(); |
1306 | 0 | parameters["signature"]["pub"][1] = getBignum(); |
1307 | |
|
1308 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
1309 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
1310 | |
|
1311 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1312 | 0 | } |
1313 | |
|
1314 | 0 | parameters["digestType"] = getRandomDigest(); |
1315 | |
|
1316 | 0 | cryptofuzz::operation::ECGDSA_Verify op(parameters); |
1317 | 0 | op.Serialize(dsOut2); |
1318 | 0 | } |
1319 | 0 | break; |
1320 | 0 | case CF_OPERATION("ECRDSA_Verify"): |
1321 | 0 | { |
1322 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1323 | |
|
1324 | 0 | if ( Pool_CurveECDSASignature.Have() == true ) { |
1325 | 0 | const auto P = Pool_CurveECDSASignature.Get(); |
1326 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1327 | |
|
1328 | 0 | parameters["signature"]["pub"][0] = getBool() ? getBignum() : P.pub_x; |
1329 | 0 | parameters["signature"]["pub"][1] = getBool() ? getBignum() : P.pub_y; |
1330 | |
|
1331 | 0 | parameters["signature"]["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1332 | 0 | auto sigS = getBool() ? getBignum() : P.sig_y; |
1333 | |
|
1334 | 0 | if ( getBool() ) { |
1335 | | /* Test ECRDSA signature malleability */ |
1336 | |
|
1337 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(P.curveID); |
1338 | 0 | if ( order != std::nullopt ) { |
1339 | 0 | const auto o = boost::multiprecision::cpp_int(*order); |
1340 | 0 | const auto s = boost::multiprecision::cpp_int(sigS); |
1341 | 0 | if ( o > s ) { |
1342 | 0 | sigS = boost::lexical_cast<std::string>(o - s); |
1343 | 0 | } |
1344 | 0 | } |
1345 | 0 | } |
1346 | |
|
1347 | 0 | parameters["signature"]["signature"][1] = sigS; |
1348 | 0 | parameters["cleartext"] = P.cleartext; |
1349 | 0 | } else { |
1350 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1351 | |
|
1352 | 0 | parameters["signature"]["pub"][0] = getBignum(); |
1353 | 0 | parameters["signature"]["pub"][1] = getBignum(); |
1354 | |
|
1355 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
1356 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
1357 | |
|
1358 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1359 | 0 | } |
1360 | |
|
1361 | 0 | parameters["digestType"] = getRandomDigest(); |
1362 | |
|
1363 | 0 | cryptofuzz::operation::ECRDSA_Verify op(parameters); |
1364 | 0 | op.Serialize(dsOut2); |
1365 | 0 | } |
1366 | 0 | break; |
1367 | 0 | case CF_OPERATION("Schnorr_Verify"): |
1368 | 0 | { |
1369 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1370 | |
|
1371 | 0 | if ( Pool_CurveECDSASignature.Have() == true ) { |
1372 | 0 | const auto P = Pool_CurveECDSASignature.Get(); |
1373 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1374 | |
|
1375 | 0 | parameters["signature"]["pub"][0] = getBool() ? getBignum() : P.pub_x; |
1376 | 0 | parameters["signature"]["pub"][1] = getBool() ? getBignum() : P.pub_y; |
1377 | |
|
1378 | 0 | parameters["signature"]["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1379 | 0 | auto sigS = getBool() ? getBignum() : P.sig_y; |
1380 | |
|
1381 | 0 | if ( getBool() ) { |
1382 | | /* Test Schnorr signature malleability */ |
1383 | |
|
1384 | 0 | const auto order = cryptofuzz::repository::ECC_CurveToOrder(P.curveID); |
1385 | 0 | if ( order != std::nullopt ) { |
1386 | 0 | const auto o = boost::multiprecision::cpp_int(*order); |
1387 | 0 | const auto s = boost::multiprecision::cpp_int(sigS); |
1388 | 0 | if ( o > s ) { |
1389 | 0 | sigS = boost::lexical_cast<std::string>(o - s); |
1390 | 0 | } |
1391 | 0 | } |
1392 | 0 | } |
1393 | |
|
1394 | 0 | parameters["signature"]["signature"][1] = sigS; |
1395 | 0 | parameters["cleartext"] = P.cleartext; |
1396 | 0 | } else { |
1397 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1398 | |
|
1399 | 0 | parameters["signature"]["pub"][0] = getBignum(); |
1400 | 0 | parameters["signature"]["pub"][1] = getBignum(); |
1401 | |
|
1402 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
1403 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
1404 | |
|
1405 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1406 | 0 | } |
1407 | |
|
1408 | 0 | parameters["digestType"] = getRandomDigest(); |
1409 | |
|
1410 | 0 | cryptofuzz::operation::Schnorr_Verify op(parameters); |
1411 | 0 | op.Serialize(dsOut2); |
1412 | 0 | } |
1413 | 0 | break; |
1414 | 0 | case CF_OPERATION("ECDSA_Recover"): |
1415 | 0 | { |
1416 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
1417 | |
|
1418 | 0 | if ( getBool() && Pool_CurveECDSASignature.Have() == true ) { |
1419 | 0 | const auto P = Pool_CurveECDSASignature.Get(); |
1420 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1421 | |
|
1422 | 0 | parameters["signature"][0] = getBool() ? getBignum() : P.sig_r; |
1423 | 0 | parameters["signature"][1] = getBool() ? getBignum() : P.sig_y; |
1424 | |
|
1425 | 0 | if ( getBool() ) { |
1426 | 0 | parameters["cleartext"] = P.cleartext; |
1427 | 0 | } else { |
1428 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1429 | 0 | } |
1430 | 0 | } else if ( getBool() && Pool_CurveECC_Point.Have() == true ) { |
1431 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1432 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1433 | |
|
1434 | 0 | parameters["signature"][0] = getBool() ? getBignum() : P.x; |
1435 | 0 | parameters["signature"][1] = getBool() ? getBignum() : P.y; |
1436 | |
|
1437 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1438 | 0 | } else { |
1439 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1440 | |
|
1441 | 0 | parameters["signature"][0] = getBignum(); |
1442 | 0 | parameters["signature"][1] = getBignum(); |
1443 | |
|
1444 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1445 | 0 | } |
1446 | |
|
1447 | 0 | parameters["id"] = PRNG() % 4; |
1448 | 0 | parameters["digestType"] = getRandomDigest(); |
1449 | |
|
1450 | 0 | cryptofuzz::operation::ECDSA_Recover op(parameters); |
1451 | 0 | op.Serialize(dsOut2); |
1452 | 0 | } |
1453 | 0 | case CF_OPERATION("ECC_GenerateKeyPair"): |
1454 | 0 | { |
1455 | 0 | parameters["modifier"] = getBuffer(PRNG() % 128); |
1456 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1457 | |
|
1458 | 0 | cryptofuzz::operation::ECC_GenerateKeyPair op(parameters); |
1459 | 0 | op.Serialize(dsOut2); |
1460 | 0 | } |
1461 | 0 | break; |
1462 | 0 | case CF_OPERATION("ECIES_Encrypt"): |
1463 | 0 | case CF_OPERATION("ECIES_Decrypt"): |
1464 | 0 | { |
1465 | 0 | parameters["modifier"] = getBuffer(PRNG() % 128); |
1466 | 0 | if ( operation == CF_OPERATION("ECIES_Encrypt") ) { |
1467 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 1024); |
1468 | 0 | } else { |
1469 | 0 | parameters["ciphertext"] = getBuffer(PRNG() % 1024); |
1470 | 0 | } |
1471 | | //parameters["cipherType"] = getRandomCipher(); |
1472 | 0 | parameters["cipherType"] = CF_CIPHER("AES_128_CBC"); |
1473 | 0 | parameters["iv_enabled"] = false; |
1474 | |
|
1475 | 0 | parameters["priv"] = getBignum(); |
1476 | |
|
1477 | 0 | if ( Pool_CurveKeypair.Have() && getBool() == true ) { |
1478 | 0 | const auto P = Pool_CurveKeypair.Get(); |
1479 | |
|
1480 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1481 | 0 | parameters["pub_x"] = P.pub_x; |
1482 | 0 | parameters["pub_y"] = P.pub_y; |
1483 | |
|
1484 | 0 | if ( Pool_CurvePrivkey.Have() && getBool() == true ) { |
1485 | 0 | const auto P2 = Pool_CurvePrivkey.Get(); |
1486 | 0 | if ( P2.curveID == P.curveID ) { |
1487 | 0 | parameters["priv"] = P2.priv; |
1488 | 0 | } |
1489 | 0 | } |
1490 | 0 | } else { |
1491 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1492 | 0 | parameters["pub_x"] = getBignum(); |
1493 | 0 | parameters["pub_y"] = getBignum(); |
1494 | 0 | } |
1495 | |
|
1496 | 0 | if ( operation == CF_OPERATION("ECIES_Encrypt") ) { |
1497 | 0 | cryptofuzz::operation::ECIES_Encrypt op(parameters); |
1498 | 0 | op.Serialize(dsOut2); |
1499 | 0 | } else { |
1500 | 0 | cryptofuzz::operation::ECIES_Decrypt op(parameters); |
1501 | 0 | op.Serialize(dsOut2); |
1502 | 0 | } |
1503 | 0 | } |
1504 | 0 | break; |
1505 | 0 | case CF_OPERATION("ECC_Point_Add"): |
1506 | 0 | { |
1507 | 0 | parameters["modifier"] = ""; |
1508 | |
|
1509 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1510 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1511 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1512 | |
|
1513 | 0 | parameters["a_x"] = getBool() ? getBignum() : P.x; |
1514 | 0 | parameters["a_y"] = getBool() ? getBignum() : P.y; |
1515 | 0 | } else { |
1516 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1517 | |
|
1518 | 0 | parameters["a_x"] = getBignum(); |
1519 | 0 | parameters["a_y"] = getBignum(); |
1520 | 0 | } |
1521 | |
|
1522 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1523 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1524 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1525 | |
|
1526 | 0 | parameters["b_x"] = getBool() ? getBignum() : P.x; |
1527 | 0 | parameters["b_y"] = getBool() ? getBignum() : P.y; |
1528 | 0 | } else { |
1529 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1530 | |
|
1531 | 0 | parameters["b_x"] = getBignum(); |
1532 | 0 | parameters["b_y"] = getBignum(); |
1533 | 0 | } |
1534 | |
|
1535 | 0 | cryptofuzz::operation::ECC_Point_Add op(parameters); |
1536 | 0 | op.Serialize(dsOut2); |
1537 | |
|
1538 | 0 | generateECCPoint(); |
1539 | 0 | } |
1540 | 0 | break; |
1541 | 0 | case CF_OPERATION("ECC_Point_Mul"): |
1542 | 0 | { |
1543 | 0 | parameters["modifier"] = ""; |
1544 | |
|
1545 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1546 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1547 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1548 | |
|
1549 | 0 | parameters["a_x"] = getBool() ? getBignum() : P.x; |
1550 | 0 | parameters["a_y"] = getBool() ? getBignum() : P.y; |
1551 | 0 | } else { |
1552 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1553 | |
|
1554 | 0 | parameters["a_x"] = getBignum(); |
1555 | 0 | parameters["a_y"] = getBignum(); |
1556 | 0 | } |
1557 | |
|
1558 | 0 | parameters["b"] = getBignum(); |
1559 | |
|
1560 | 0 | cryptofuzz::operation::ECC_Point_Mul op(parameters); |
1561 | 0 | op.Serialize(dsOut2); |
1562 | |
|
1563 | 0 | generateECCPoint(); |
1564 | 0 | } |
1565 | 0 | break; |
1566 | 0 | case CF_OPERATION("ECC_Point_Neg"): |
1567 | 0 | { |
1568 | 0 | parameters["modifier"] = ""; |
1569 | |
|
1570 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1571 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1572 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1573 | |
|
1574 | 0 | parameters["a_x"] = getBool() ? getBignum() : P.x; |
1575 | 0 | parameters["a_y"] = getBool() ? getBignum() : P.y; |
1576 | 0 | } else { |
1577 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1578 | |
|
1579 | 0 | parameters["a_x"] = getBignum(); |
1580 | 0 | parameters["a_y"] = getBignum(); |
1581 | 0 | } |
1582 | |
|
1583 | 0 | cryptofuzz::operation::ECC_Point_Neg op(parameters); |
1584 | 0 | op.Serialize(dsOut2); |
1585 | |
|
1586 | 0 | generateECCPoint(); |
1587 | 0 | } |
1588 | 0 | break; |
1589 | 0 | case CF_OPERATION("ECC_Point_Dbl"): |
1590 | 0 | { |
1591 | 0 | parameters["modifier"] = ""; |
1592 | |
|
1593 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1594 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1595 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1596 | |
|
1597 | 0 | parameters["a_x"] = getBool() ? getBignum() : P.x; |
1598 | 0 | parameters["a_y"] = getBool() ? getBignum() : P.y; |
1599 | 0 | } else { |
1600 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1601 | |
|
1602 | 0 | parameters["a_x"] = getBignum(); |
1603 | 0 | parameters["a_y"] = getBignum(); |
1604 | 0 | } |
1605 | |
|
1606 | 0 | cryptofuzz::operation::ECC_Point_Dbl op(parameters); |
1607 | 0 | op.Serialize(dsOut2); |
1608 | |
|
1609 | 0 | generateECCPoint(); |
1610 | 0 | } |
1611 | 0 | break; |
1612 | 0 | case CF_OPERATION("ECC_Point_Cmp"): |
1613 | 0 | { |
1614 | 0 | parameters["modifier"] = ""; |
1615 | |
|
1616 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1617 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1618 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1619 | |
|
1620 | 0 | parameters["a_x"] = getBool() ? getBignum() : P.x; |
1621 | 0 | parameters["a_y"] = getBool() ? getBignum() : P.y; |
1622 | 0 | } else { |
1623 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1624 | |
|
1625 | 0 | parameters["a_x"] = getBignum(); |
1626 | 0 | parameters["a_y"] = getBignum(); |
1627 | 0 | } |
1628 | |
|
1629 | 0 | if ( Pool_CurveECC_Point.Have() == true ) { |
1630 | 0 | const auto P = Pool_CurveECC_Point.Get(); |
1631 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1632 | |
|
1633 | 0 | parameters["b_x"] = getBool() ? getBignum() : P.x; |
1634 | 0 | parameters["b_y"] = getBool() ? getBignum() : P.y; |
1635 | 0 | } else { |
1636 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1637 | |
|
1638 | 0 | parameters["b_x"] = getBignum(); |
1639 | 0 | parameters["b_y"] = getBignum(); |
1640 | 0 | } |
1641 | |
|
1642 | 0 | cryptofuzz::operation::ECC_Point_Cmp op(parameters); |
1643 | 0 | op.Serialize(dsOut2); |
1644 | |
|
1645 | 0 | generateECCPoint(); |
1646 | 0 | } |
1647 | 0 | break; |
1648 | 0 | case CF_OPERATION("KDF_SCRYPT"): |
1649 | 0 | { |
1650 | 0 | size_t numParts = 0; |
1651 | |
|
1652 | 0 | numParts++; /* modifier */ |
1653 | 0 | numParts++; /* password */ |
1654 | 0 | numParts++; /* salt */ |
1655 | |
|
1656 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1657 | |
|
1658 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1659 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1660 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1661 | 0 | parameters["N"] = PRNG() % 5; |
1662 | 0 | parameters["r"] = PRNG() % 9; |
1663 | 0 | parameters["p"] = PRNG() % 5; |
1664 | 0 | parameters["keySize"] = PRNG() % 1024; |
1665 | |
|
1666 | 0 | cryptofuzz::operation::KDF_SCRYPT op(parameters); |
1667 | 0 | op.Serialize(dsOut2); |
1668 | 0 | } |
1669 | 0 | break; |
1670 | 0 | case CF_OPERATION("KDF_HKDF"): |
1671 | 0 | { |
1672 | 0 | size_t numParts = 0; |
1673 | |
|
1674 | 0 | numParts++; /* modifier */ |
1675 | 0 | numParts++; /* password */ |
1676 | 0 | numParts++; /* salt */ |
1677 | 0 | numParts++; /* info */ |
1678 | |
|
1679 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1680 | |
|
1681 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1682 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1683 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1684 | 0 | parameters["info"] = getBuffer(lengths[3]); |
1685 | 0 | parameters["keySize"] = PRNG() % 17000; |
1686 | 0 | parameters["digestType"] = getRandomDigest(); |
1687 | |
|
1688 | 0 | cryptofuzz::operation::KDF_HKDF op(parameters); |
1689 | 0 | op.Serialize(dsOut2); |
1690 | 0 | } |
1691 | 0 | break; |
1692 | 0 | case CF_OPERATION("KDF_TLS1_PRF"): |
1693 | 0 | { |
1694 | 0 | size_t numParts = 0; |
1695 | |
|
1696 | 0 | numParts++; /* modifier */ |
1697 | 0 | numParts++; /* secret */ |
1698 | 0 | numParts++; /* seed */ |
1699 | |
|
1700 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1701 | |
|
1702 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1703 | 0 | parameters["secret"] = getBuffer(lengths[1]); |
1704 | 0 | parameters["seed"] = getBuffer(lengths[2]); |
1705 | 0 | parameters["keySize"] = PRNG() % 1024; |
1706 | 0 | parameters["digestType"] = getRandomDigest(); |
1707 | |
|
1708 | 0 | cryptofuzz::operation::KDF_TLS1_PRF op(parameters); |
1709 | 0 | op.Serialize(dsOut2); |
1710 | 0 | } |
1711 | 0 | break; |
1712 | 0 | case CF_OPERATION("KDF_PBKDF"): |
1713 | 0 | { |
1714 | 0 | size_t numParts = 0; |
1715 | |
|
1716 | 0 | numParts++; /* modifier */ |
1717 | 0 | numParts++; /* password */ |
1718 | 0 | numParts++; /* salt */ |
1719 | |
|
1720 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1721 | |
|
1722 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1723 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1724 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1725 | 0 | parameters["iterations"] = PRNG() % 5; |
1726 | 0 | parameters["keySize"] = PRNG() % 1024; |
1727 | 0 | parameters["digestType"] = getRandomDigest(); |
1728 | |
|
1729 | 0 | cryptofuzz::operation::KDF_PBKDF op(parameters); |
1730 | 0 | op.Serialize(dsOut2); |
1731 | 0 | } |
1732 | 0 | break; |
1733 | 0 | case CF_OPERATION("KDF_PBKDF1"): |
1734 | 0 | { |
1735 | 0 | size_t numParts = 0; |
1736 | |
|
1737 | 0 | numParts++; /* modifier */ |
1738 | 0 | numParts++; /* password */ |
1739 | 0 | numParts++; /* salt */ |
1740 | |
|
1741 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1742 | |
|
1743 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1744 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1745 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1746 | 0 | parameters["iterations"] = PRNG() % 5; |
1747 | 0 | parameters["keySize"] = PRNG() % 1024; |
1748 | 0 | parameters["digestType"] = getRandomDigest(); |
1749 | |
|
1750 | 0 | cryptofuzz::operation::KDF_PBKDF op(parameters); |
1751 | 0 | op.Serialize(dsOut2); |
1752 | 0 | } |
1753 | 0 | break; |
1754 | 0 | case CF_OPERATION("KDF_PBKDF2"): |
1755 | 0 | { |
1756 | 0 | size_t numParts = 0; |
1757 | |
|
1758 | 0 | numParts++; /* modifier */ |
1759 | 0 | numParts++; /* password */ |
1760 | 0 | numParts++; /* salt */ |
1761 | |
|
1762 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1763 | |
|
1764 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1765 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1766 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1767 | 0 | parameters["iterations"] = PRNG() % 5; |
1768 | 0 | parameters["keySize"] = PRNG() % 1024; |
1769 | 0 | parameters["digestType"] = getRandomDigest(); |
1770 | |
|
1771 | 0 | cryptofuzz::operation::KDF_PBKDF2 op(parameters); |
1772 | 0 | op.Serialize(dsOut2); |
1773 | 0 | } |
1774 | 0 | break; |
1775 | 0 | case CF_OPERATION("KDF_ARGON2"): |
1776 | 0 | { |
1777 | 0 | size_t numParts = 0; |
1778 | |
|
1779 | 0 | numParts++; /* modifier */ |
1780 | 0 | numParts++; /* password */ |
1781 | 0 | numParts++; /* salt */ |
1782 | |
|
1783 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1784 | |
|
1785 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1786 | 0 | parameters["password"] = getBuffer(lengths[1]); |
1787 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1788 | 0 | parameters["type"] = PRNG() % 3; |
1789 | 0 | parameters["threads"] = PRNG() % 256; |
1790 | 0 | parameters["memory"] = PRNG() % (64*1024); |
1791 | 0 | parameters["iterations"] = PRNG() % 3; |
1792 | 0 | parameters["keySize"] = PRNG() % 1024; |
1793 | |
|
1794 | 0 | cryptofuzz::operation::KDF_ARGON2 op(parameters); |
1795 | 0 | op.Serialize(dsOut2); |
1796 | 0 | } |
1797 | 0 | break; |
1798 | 0 | case CF_OPERATION("KDF_SSH"): |
1799 | 0 | { |
1800 | 0 | size_t numParts = 0; |
1801 | |
|
1802 | 0 | numParts++; /* modifier */ |
1803 | 0 | numParts++; /* key */ |
1804 | 0 | numParts++; /* xcghash */ |
1805 | 0 | numParts++; /* session_id */ |
1806 | |
|
1807 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1808 | |
|
1809 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1810 | 0 | parameters["key"] = getBuffer(lengths[1]); |
1811 | 0 | parameters["xcghash"] = getBuffer(lengths[2]); |
1812 | 0 | parameters["session_id"] = getBuffer(lengths[3]); |
1813 | 0 | parameters["type"] = getBuffer(1); |
1814 | 0 | parameters["keySize"] = PRNG() % 1024; |
1815 | 0 | parameters["digestType"] = getRandomDigest(); |
1816 | |
|
1817 | 0 | cryptofuzz::operation::KDF_SSH op(parameters); |
1818 | 0 | op.Serialize(dsOut2); |
1819 | 0 | } |
1820 | 0 | break; |
1821 | 0 | case CF_OPERATION("KDF_X963"): |
1822 | 0 | { |
1823 | 0 | size_t numParts = 0; |
1824 | |
|
1825 | 0 | numParts++; /* modifier */ |
1826 | 0 | numParts++; /* secret */ |
1827 | 0 | numParts++; /* info */ |
1828 | |
|
1829 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1830 | |
|
1831 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1832 | 0 | parameters["secret"] = getBuffer(lengths[1]); |
1833 | 0 | parameters["info"] = getBuffer(lengths[2]); |
1834 | 0 | parameters["keySize"] = PRNG() % 1024; |
1835 | 0 | parameters["digestType"] = getRandomDigest(); |
1836 | |
|
1837 | 0 | cryptofuzz::operation::KDF_X963 op(parameters); |
1838 | 0 | op.Serialize(dsOut2); |
1839 | 0 | } |
1840 | 0 | break; |
1841 | 0 | case CF_OPERATION("KDF_SP_800_108"): |
1842 | 0 | { |
1843 | 0 | size_t numParts = 0; |
1844 | |
|
1845 | 0 | numParts++; /* modifier */ |
1846 | 0 | numParts++; /* secret */ |
1847 | 0 | numParts++; /* salt */ |
1848 | 0 | numParts++; /* label */ |
1849 | |
|
1850 | 0 | const auto lengths = SplitLength(maxSize - 64, numParts); |
1851 | |
|
1852 | 0 | if ( getBool() == true ) { |
1853 | | /* MAC = HMAC */ |
1854 | 0 | parameters["mech"]["mode"] = true; |
1855 | 0 | parameters["mech"]["type"] = getRandomDigest(); |
1856 | 0 | } else { |
1857 | | /* MAC = CMAC */ |
1858 | 0 | parameters["mech"]["mode"] = false; |
1859 | 0 | parameters["mech"]["type"] = getRandomCipher(); |
1860 | 0 | } |
1861 | |
|
1862 | 0 | parameters["modifier"] = getBuffer(lengths[0]); |
1863 | 0 | parameters["secret"] = getBuffer(lengths[1]); |
1864 | 0 | parameters["salt"] = getBuffer(lengths[2]); |
1865 | 0 | parameters["label"] = getBuffer(lengths[3]); |
1866 | 0 | parameters["mode"] = PRNG() % 3; |
1867 | 0 | parameters["keySize"] = PRNG() % 17000; |
1868 | |
|
1869 | 0 | cryptofuzz::operation::KDF_SP_800_108 op(parameters); |
1870 | 0 | op.Serialize(dsOut2); |
1871 | 0 | } |
1872 | 0 | break; |
1873 | 0 | case CF_OPERATION("DH_GenerateKeyPair"): |
1874 | 0 | { |
1875 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1876 | 0 | parameters["prime"] = getBignum(); |
1877 | 0 | parameters["base"] = getBignum(); |
1878 | |
|
1879 | 0 | cryptofuzz::operation::DH_GenerateKeyPair op(parameters); |
1880 | 0 | op.Serialize(dsOut2); |
1881 | 0 | } |
1882 | 0 | break; |
1883 | 0 | case CF_OPERATION("DH_Derive"): |
1884 | 0 | { |
1885 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1886 | 0 | parameters["prime"] = getBignum(); |
1887 | 0 | parameters["base"] = getBignum(); |
1888 | 0 | if ( Pool_DH_PublicKey.Have() && getBool() == true ) { |
1889 | 0 | parameters["pub"] = Pool_DH_PublicKey.Get(); |
1890 | 0 | } else { |
1891 | 0 | parameters["pub"] = getBignum(); |
1892 | 0 | } |
1893 | |
|
1894 | 0 | if ( Pool_DH_PrivateKey.Have() && getBool() == true ) { |
1895 | 0 | parameters["priv"] = Pool_DH_PrivateKey.Get(); |
1896 | 0 | } else { |
1897 | 0 | parameters["priv"] = getBignum(); |
1898 | 0 | } |
1899 | |
|
1900 | 0 | cryptofuzz::operation::DH_Derive op(parameters); |
1901 | 0 | op.Serialize(dsOut2); |
1902 | 0 | } |
1903 | 0 | break; |
1904 | 0 | case CF_OPERATION("BLS_PrivateToPublic"): |
1905 | 0 | { |
1906 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1907 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1908 | |
|
1909 | 0 | parameters["priv"] = getBignum(); |
1910 | |
|
1911 | 0 | cryptofuzz::operation::BLS_PrivateToPublic op(parameters); |
1912 | 0 | op.Serialize(dsOut2); |
1913 | 0 | } |
1914 | 0 | break; |
1915 | 0 | case CF_OPERATION("BLS_PrivateToPublic_G2"): |
1916 | 0 | { |
1917 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1918 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1919 | |
|
1920 | 0 | parameters["priv"] = getBignum(); |
1921 | |
|
1922 | 0 | cryptofuzz::operation::BLS_PrivateToPublic_G2 op(parameters); |
1923 | 0 | op.Serialize(dsOut2); |
1924 | 0 | } |
1925 | 0 | break; |
1926 | 0 | case CF_OPERATION("BLS_Sign"): |
1927 | 0 | { |
1928 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1929 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1930 | 0 | const auto hashOrPoint = getBool(); |
1931 | | //const auto hashOrPoint = false; |
1932 | 0 | parameters["hashOrPoint"] = hashOrPoint; |
1933 | 0 | if ( hashOrPoint == true ) { |
1934 | | //parameters["cleartext"] = getBuffer(PRNG() % 32); |
1935 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
1936 | 0 | parameters["point_v"] = ""; |
1937 | 0 | parameters["point_w"] = ""; |
1938 | 0 | parameters["point_x"] = ""; |
1939 | 0 | parameters["point_y"] = ""; |
1940 | 0 | } else { |
1941 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
1942 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
1943 | 0 | parameters["point_v"] = GET_OR_BIGNUM(P.g2_v); |
1944 | 0 | parameters["point_w"] = GET_OR_BIGNUM(P.g2_w); |
1945 | 0 | parameters["point_x"] = GET_OR_BIGNUM(P.g2_x); |
1946 | 0 | parameters["point_y"] = GET_OR_BIGNUM(P.g2_y); |
1947 | 0 | } else { |
1948 | 0 | parameters["point_v"] = getBignum(); |
1949 | 0 | parameters["point_w"] = getBignum(); |
1950 | 0 | parameters["point_x"] = getBignum(); |
1951 | 0 | parameters["point_y"] = getBignum(); |
1952 | 0 | } |
1953 | |
|
1954 | 0 | parameters["cleartext"] = ""; |
1955 | 0 | } |
1956 | 0 | parameters["dest"] = getBool() ? getBuffer(PRNG() % 512) : get_BLS_predefined_DST(); |
1957 | 0 | parameters["aug"] = ""; |
1958 | 0 | parameters["priv"] = getBignum(); |
1959 | |
|
1960 | 0 | cryptofuzz::operation::BLS_Sign op(parameters); |
1961 | 0 | op.Serialize(dsOut2); |
1962 | 0 | } |
1963 | 0 | break; |
1964 | 0 | case CF_OPERATION("BLS_Verify"): |
1965 | 0 | { |
1966 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
1967 | |
|
1968 | 0 | if ( Pool_CurveBLSSignature.Have() == true ) { |
1969 | 0 | const auto P = Pool_CurveBLSSignature.Get(); |
1970 | |
|
1971 | 0 | parameters["curveType"] = hint_ecc_mont(P.curveID); |
1972 | 0 | parameters["hashOrPoint"] = P.hashOrPoint; |
1973 | 0 | parameters["point_v"] = GET_OR_BIGNUM(P.point_v); |
1974 | 0 | parameters["point_w"] = GET_OR_BIGNUM(P.point_w); |
1975 | 0 | parameters["point_x"] = GET_OR_BIGNUM(P.point_x); |
1976 | 0 | parameters["point_y"] = GET_OR_BIGNUM(P.point_y); |
1977 | 0 | parameters["cleartext"] = P.cleartext; |
1978 | 0 | parameters["dest"] = P.dest; |
1979 | 0 | parameters["aug"] = P.aug; |
1980 | 0 | parameters["pub_x"] = GET_OR_BIGNUM(P.pub_x); |
1981 | 0 | parameters["pub_y"] = GET_OR_BIGNUM(P.pub_y); |
1982 | 0 | parameters["sig_v"] = GET_OR_BIGNUM(P.sig_v); |
1983 | 0 | parameters["sig_w"] = GET_OR_BIGNUM(P.sig_w); |
1984 | 0 | parameters["sig_x"] = GET_OR_BIGNUM(P.sig_x); |
1985 | 0 | parameters["sig_y"] = GET_OR_BIGNUM(P.sig_y); |
1986 | 0 | } else { |
1987 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
1988 | 0 | const auto hashOrPoint = getBool(); |
1989 | 0 | parameters["hashOrPoint"] = hashOrPoint; |
1990 | 0 | if ( hashOrPoint == true ) { |
1991 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 32); |
1992 | 0 | parameters["point_v"] = ""; |
1993 | 0 | parameters["point_w"] = ""; |
1994 | 0 | parameters["point_x"] = ""; |
1995 | 0 | parameters["point_y"] = ""; |
1996 | 0 | } else { |
1997 | 0 | parameters["point_v"] = getBignum(); |
1998 | 0 | parameters["point_w"] = getBignum(); |
1999 | 0 | parameters["point_x"] = getBignum(); |
2000 | 0 | parameters["point_y"] = getBignum(); |
2001 | 0 | parameters["cleartext"] = ""; |
2002 | 0 | } |
2003 | 0 | parameters["dest"] = getBool() ? getBuffer(PRNG() % 512) : get_BLS_predefined_DST(); |
2004 | 0 | parameters["pub_x"] = getBignum(); |
2005 | 0 | parameters["pub_y"] = getBignum(); |
2006 | 0 | parameters["sig_v"] = getBignum(); |
2007 | 0 | parameters["sig_w"] = getBignum(); |
2008 | 0 | parameters["sig_x"] = getBignum(); |
2009 | 0 | parameters["sig_y"] = getBignum(); |
2010 | 0 | } |
2011 | |
|
2012 | 0 | cryptofuzz::operation::BLS_Verify op(parameters); |
2013 | 0 | op.Serialize(dsOut2); |
2014 | 0 | } |
2015 | 0 | break; |
2016 | 0 | case CF_OPERATION("BLS_BatchSign"): |
2017 | 0 | { |
2018 | 0 | parameters["modifier"] = ""; |
2019 | | |
2020 | | //const size_t num = PRNG() % 100; |
2021 | | //const size_t num = (PRNG() % 50) + 30; |
2022 | 0 | const size_t num = (PRNG() % 8) + 1; |
2023 | |
|
2024 | 0 | parameters["bf"] = nlohmann::json::array(); |
2025 | |
|
2026 | 0 | for (size_t i = 0; i < num; i++) { |
2027 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2028 | |
|
2029 | 0 | nlohmann::json p; |
2030 | |
|
2031 | 0 | p["priv"] = getBignum(); |
2032 | 0 | p["g1_x"] = P.g1_x; |
2033 | 0 | p["g1_y"] = P.g1_y; |
2034 | |
|
2035 | 0 | parameters["bf"].push_back(p); |
2036 | 0 | } |
2037 | |
|
2038 | 0 | cryptofuzz::operation::BLS_BatchSign op(parameters); |
2039 | 0 | op.Serialize(dsOut2); |
2040 | |
|
2041 | 0 | generateECCPoint(); |
2042 | 0 | } |
2043 | 0 | break; |
2044 | 0 | case CF_OPERATION("BLS_BatchVerify"): |
2045 | 0 | { |
2046 | 0 | parameters["modifier"] = ""; |
2047 | 0 | parameters["dest"] = get_BLS_predefined_DST(); |
2048 | |
|
2049 | 0 | std::vector< |
2050 | 0 | std::pair< |
2051 | 0 | std::array<std::string, 2>, |
2052 | 0 | std::array<std::string, 4> |
2053 | 0 | > |
2054 | 0 | > points; |
2055 | |
|
2056 | 0 | if ( Pool_BLS_BatchSignature.Have() == true ) { |
2057 | 0 | const auto sig = Pool_BLS_BatchSignature.Get(); |
2058 | |
|
2059 | 0 | for (const auto& mp : sig.msgpub) { |
2060 | 0 | std::array<std::string, 2> g1; |
2061 | 0 | std::array<std::string, 4> g2; |
2062 | |
|
2063 | 0 | switch ( PRNG() % 3 ) { |
2064 | 0 | case 0: |
2065 | 0 | { |
2066 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2067 | 0 | g1 = {P.g1_x, P.g1_y}; |
2068 | 0 | } |
2069 | 0 | break; |
2070 | 0 | case 1: |
2071 | 0 | g1 = {mp.first.g1_x, mp.first.g1_y}; |
2072 | 0 | break; |
2073 | 0 | case 2: |
2074 | 0 | g1 = {getBignum(), getBignum()}; |
2075 | 0 | break; |
2076 | 0 | } |
2077 | | |
2078 | 0 | if ( (PRNG()%3) == 0 ) { |
2079 | 0 | const auto P2 = Pool_CurveBLSG2.Get(); |
2080 | 0 | g2 = {P2.g2_v, P2.g2_w, P2.g2_x, P2.g2_y}; |
2081 | 0 | } else { |
2082 | 0 | g2 = {mp.second.g2_v, mp.second.g2_w, mp.second.g2_x, mp.second.g2_y}; |
2083 | 0 | } |
2084 | |
|
2085 | 0 | points.push_back({g1, g2}); |
2086 | 0 | } |
2087 | | |
2088 | 0 | parameters["bf"] = nlohmann::json::array(); |
2089 | |
|
2090 | 0 | std::shuffle(std::begin(points), std::end(points), rng); |
2091 | |
|
2092 | 0 | for (const auto& p : points) { |
2093 | 0 | nlohmann::json cur; |
2094 | 0 | cur["g1_x"] = p.first[0]; |
2095 | 0 | cur["g1_y"] = p.first[1]; |
2096 | |
|
2097 | 0 | cur["g2_v"] = p.second[0]; |
2098 | 0 | cur["g2_w"] = p.second[1]; |
2099 | 0 | cur["g2_x"] = p.second[2]; |
2100 | 0 | cur["g2_y"] = p.second[3]; |
2101 | 0 | parameters["bf"].push_back(cur); |
2102 | 0 | } |
2103 | |
|
2104 | 0 | cryptofuzz::operation::BLS_BatchVerify op(parameters); |
2105 | 0 | op.Serialize(dsOut2); |
2106 | 0 | } else { |
2107 | 0 | goto end; |
2108 | 0 | } |
2109 | 0 | } |
2110 | 0 | break; |
2111 | 0 | case CF_OPERATION("BLS_IsG1OnCurve"): |
2112 | 0 | { |
2113 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2114 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2115 | |
|
2116 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2117 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2118 | 0 | parameters["g1_x"] = GET_OR_BIGNUM(P.g1_x); |
2119 | 0 | parameters["g1_y"] = GET_OR_BIGNUM(P.g1_y); |
2120 | 0 | } else { |
2121 | 0 | parameters["g1_x"] = getBignum(); |
2122 | 0 | parameters["g1_y"] = getBignum(); |
2123 | 0 | } |
2124 | |
|
2125 | 0 | cryptofuzz::operation::BLS_IsG1OnCurve op(parameters); |
2126 | 0 | op.Serialize(dsOut2); |
2127 | |
|
2128 | 0 | generateECCPoint(); |
2129 | 0 | } |
2130 | 0 | break; |
2131 | 0 | case CF_OPERATION("BLS_IsG2OnCurve"): |
2132 | 0 | { |
2133 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2134 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2135 | |
|
2136 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2137 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2138 | 0 | parameters["g2_v"] = GET_OR_BIGNUM(P.g2_v); |
2139 | 0 | parameters["g2_w"] = GET_OR_BIGNUM(P.g2_w); |
2140 | 0 | parameters["g2_x"] = GET_OR_BIGNUM(P.g2_x); |
2141 | 0 | parameters["g2_y"] = GET_OR_BIGNUM(P.g2_y); |
2142 | 0 | } else { |
2143 | 0 | parameters["g2_v"] = getBignum(); |
2144 | 0 | parameters["g2_w"] = getBignum(); |
2145 | 0 | parameters["g2_x"] = getBignum(); |
2146 | 0 | parameters["g2_y"] = getBignum(); |
2147 | 0 | } |
2148 | |
|
2149 | 0 | cryptofuzz::operation::BLS_IsG2OnCurve op(parameters); |
2150 | 0 | op.Serialize(dsOut2); |
2151 | 0 | } |
2152 | 0 | break; |
2153 | 0 | case CF_OPERATION("BLS_GenerateKeyPair"): |
2154 | 0 | { |
2155 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2156 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2157 | 0 | parameters["ikm"] = getBuffer(PRNG() % 512); |
2158 | 0 | parameters["info"] = getBuffer(PRNG() % 512); |
2159 | |
|
2160 | 0 | cryptofuzz::operation::BLS_GenerateKeyPair op(parameters); |
2161 | 0 | op.Serialize(dsOut2); |
2162 | 0 | } |
2163 | 0 | break; |
2164 | 0 | case CF_OPERATION("BLS_Decompress_G1"): |
2165 | 0 | { |
2166 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2167 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2168 | 0 | parameters["compressed"] = getBignum(); |
2169 | |
|
2170 | 0 | cryptofuzz::operation::BLS_Decompress_G1 op(parameters); |
2171 | 0 | op.Serialize(dsOut2); |
2172 | 0 | } |
2173 | 0 | break; |
2174 | 0 | case CF_OPERATION("BLS_Compress_G1"): |
2175 | 0 | { |
2176 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2177 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2178 | |
|
2179 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2180 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2181 | 0 | parameters["g1_x"] = GET_OR_BIGNUM(P.g1_x); |
2182 | 0 | parameters["g1_y"] = GET_OR_BIGNUM(P.g1_y); |
2183 | 0 | } else { |
2184 | 0 | parameters["g1_x"] = getBignum(); |
2185 | 0 | parameters["g1_y"] = getBignum(); |
2186 | 0 | } |
2187 | |
|
2188 | 0 | cryptofuzz::operation::BLS_Compress_G1 op(parameters); |
2189 | 0 | op.Serialize(dsOut2); |
2190 | |
|
2191 | 0 | generateECCPoint(); |
2192 | 0 | } |
2193 | 0 | break; |
2194 | 0 | case CF_OPERATION("BLS_Decompress_G2"): |
2195 | 0 | { |
2196 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2197 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2198 | 0 | parameters["g1_x"] = getBignum(); |
2199 | 0 | parameters["g1_y"] = getBignum(); |
2200 | |
|
2201 | 0 | cryptofuzz::operation::BLS_Decompress_G2 op(parameters); |
2202 | 0 | op.Serialize(dsOut2); |
2203 | 0 | } |
2204 | 0 | break; |
2205 | 0 | case CF_OPERATION("BLS_Compress_G2"): |
2206 | 0 | { |
2207 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2208 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2209 | |
|
2210 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2211 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2212 | 0 | parameters["g2_v"] = GET_OR_BIGNUM(P.g2_v); |
2213 | 0 | parameters["g2_w"] = GET_OR_BIGNUM(P.g2_w); |
2214 | 0 | parameters["g2_x"] = GET_OR_BIGNUM(P.g2_x); |
2215 | 0 | parameters["g2_y"] = GET_OR_BIGNUM(P.g2_y); |
2216 | 0 | } else { |
2217 | 0 | parameters["g2_v"] = getBignum(); |
2218 | 0 | parameters["g2_w"] = getBignum(); |
2219 | 0 | parameters["g2_x"] = getBignum(); |
2220 | 0 | parameters["g2_y"] = getBignum(); |
2221 | 0 | } |
2222 | |
|
2223 | 0 | cryptofuzz::operation::BLS_Compress_G2 op(parameters); |
2224 | 0 | op.Serialize(dsOut2); |
2225 | 0 | } |
2226 | 0 | break; |
2227 | 0 | case CF_OPERATION("BLS_HashToG1"): |
2228 | 0 | { |
2229 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2230 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2231 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 1024); |
2232 | 0 | parameters["dest"] = getBool() ? getBuffer(PRNG() % 512) : get_BLS_predefined_DST(); |
2233 | |
|
2234 | 0 | parameters["aug"] = getBuffer(PRNG() % 1024); |
2235 | |
|
2236 | 0 | cryptofuzz::operation::BLS_HashToG1 op(parameters); |
2237 | 0 | op.Serialize(dsOut2); |
2238 | 0 | } |
2239 | 0 | break; |
2240 | 0 | case CF_OPERATION("BLS_HashToG2"): |
2241 | 0 | { |
2242 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2243 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2244 | 0 | parameters["cleartext"] = getBuffer(PRNG() % 1024); |
2245 | 0 | parameters["dest"] = getBool() ? getBuffer(PRNG() % 512) : get_BLS_predefined_DST(); |
2246 | 0 | parameters["aug"] = getBuffer(PRNG() % 1024); |
2247 | |
|
2248 | 0 | cryptofuzz::operation::BLS_HashToG2 op(parameters); |
2249 | 0 | op.Serialize(dsOut2); |
2250 | 0 | } |
2251 | 0 | break; |
2252 | 0 | case CF_OPERATION("BLS_MapToG1"): |
2253 | 0 | { |
2254 | 0 | parameters["modifier"] = ""; |
2255 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2256 | 0 | parameters["u"] = getBignum(); |
2257 | 0 | parameters["v"] = getBignum(); |
2258 | |
|
2259 | 0 | cryptofuzz::operation::BLS_MapToG1 op(parameters); |
2260 | 0 | op.Serialize(dsOut2); |
2261 | 0 | } |
2262 | 0 | break; |
2263 | 0 | case CF_OPERATION("BLS_MapToG2"): |
2264 | 0 | { |
2265 | 0 | parameters["modifier"] = ""; |
2266 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2267 | 0 | parameters["u"][0] = getBignum(); |
2268 | 0 | parameters["u"][1] = getBignum(); |
2269 | 0 | parameters["v"][0] = getBignum(); |
2270 | 0 | parameters["v"][1] = getBignum(); |
2271 | |
|
2272 | 0 | cryptofuzz::operation::BLS_MapToG2 op(parameters); |
2273 | 0 | op.Serialize(dsOut2); |
2274 | 0 | } |
2275 | 0 | break; |
2276 | 0 | case CF_OPERATION("BLS_Pairing"): |
2277 | 0 | { |
2278 | 0 | parameters["modifier"] = ""; |
2279 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2280 | |
|
2281 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2282 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2283 | 0 | parameters["g1_x"] = GET_OR_BIGNUM(P.g1_x); |
2284 | 0 | parameters["g1_y"] = GET_OR_BIGNUM(P.g1_y); |
2285 | 0 | } else { |
2286 | 0 | parameters["g1_x"] = getBignum(); |
2287 | 0 | parameters["g1_y"] = getBignum(); |
2288 | 0 | } |
2289 | |
|
2290 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2291 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2292 | 0 | parameters["g2_v"] = GET_OR_BIGNUM(P.g2_v); |
2293 | 0 | parameters["g2_w"] = GET_OR_BIGNUM(P.g2_w); |
2294 | 0 | parameters["g2_x"] = GET_OR_BIGNUM(P.g2_x); |
2295 | 0 | parameters["g2_y"] = GET_OR_BIGNUM(P.g2_y); |
2296 | 0 | } else { |
2297 | 0 | parameters["g2_v"] = getBignum(); |
2298 | 0 | parameters["g2_w"] = getBignum(); |
2299 | 0 | parameters["g2_x"] = getBignum(); |
2300 | 0 | parameters["g2_y"] = getBignum(); |
2301 | 0 | } |
2302 | |
|
2303 | 0 | cryptofuzz::operation::BLS_Pairing op(parameters); |
2304 | 0 | op.Serialize(dsOut2); |
2305 | |
|
2306 | 0 | generateECCPoint(); |
2307 | 0 | } |
2308 | 0 | break; |
2309 | 0 | case CF_OPERATION("BLS_MillerLoop"): |
2310 | 0 | { |
2311 | 0 | parameters["modifier"] = ""; |
2312 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2313 | |
|
2314 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2315 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2316 | 0 | parameters["g1_x"] = GET_OR_BIGNUM(P.g1_x); |
2317 | 0 | parameters["g1_y"] = GET_OR_BIGNUM(P.g1_y); |
2318 | 0 | } else { |
2319 | 0 | parameters["g1_x"] = getBignum(); |
2320 | 0 | parameters["g1_y"] = getBignum(); |
2321 | 0 | } |
2322 | |
|
2323 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2324 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2325 | 0 | parameters["g2_v"] = GET_OR_BIGNUM(P.g2_v); |
2326 | 0 | parameters["g2_w"] = GET_OR_BIGNUM(P.g2_w); |
2327 | 0 | parameters["g2_x"] = GET_OR_BIGNUM(P.g2_x); |
2328 | 0 | parameters["g2_y"] = GET_OR_BIGNUM(P.g2_y); |
2329 | 0 | } else { |
2330 | 0 | parameters["g2_v"] = getBignum(); |
2331 | 0 | parameters["g2_w"] = getBignum(); |
2332 | 0 | parameters["g2_x"] = getBignum(); |
2333 | 0 | parameters["g2_y"] = getBignum(); |
2334 | 0 | } |
2335 | |
|
2336 | 0 | cryptofuzz::operation::BLS_MillerLoop op(parameters); |
2337 | 0 | op.Serialize(dsOut2); |
2338 | |
|
2339 | 0 | generateECCPoint(); |
2340 | 0 | } |
2341 | 0 | break; |
2342 | 0 | case CF_OPERATION("BLS_FinalExp"): |
2343 | 0 | { |
2344 | 0 | parameters["modifier"] = ""; |
2345 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2346 | |
|
2347 | 0 | if ( Pool_Fp12.Have() && getBool() == true ) { |
2348 | 0 | const auto Fp12 = Pool_Fp12.Get(); |
2349 | |
|
2350 | 0 | parameters["fp12"][0] = Fp12.bn1; |
2351 | 0 | parameters["fp12"][1] = Fp12.bn2; |
2352 | 0 | parameters["fp12"][2] = Fp12.bn3; |
2353 | 0 | parameters["fp12"][3] = Fp12.bn4; |
2354 | 0 | parameters["fp12"][4] = Fp12.bn5; |
2355 | 0 | parameters["fp12"][5] = Fp12.bn6; |
2356 | 0 | parameters["fp12"][6] = Fp12.bn7; |
2357 | 0 | parameters["fp12"][7] = Fp12.bn8; |
2358 | 0 | parameters["fp12"][8] = Fp12.bn9; |
2359 | 0 | parameters["fp12"][9] = Fp12.bn10; |
2360 | 0 | parameters["fp12"][10] = Fp12.bn11; |
2361 | 0 | parameters["fp12"][11] = Fp12.bn12; |
2362 | 0 | } else { |
2363 | 0 | parameters["fp12"][0] = getBignum(); |
2364 | 0 | parameters["fp12"][1] = getBignum(); |
2365 | 0 | parameters["fp12"][2] = getBignum(); |
2366 | 0 | parameters["fp12"][3] = getBignum(); |
2367 | 0 | parameters["fp12"][4] = getBignum(); |
2368 | 0 | parameters["fp12"][5] = getBignum(); |
2369 | 0 | parameters["fp12"][6] = getBignum(); |
2370 | 0 | parameters["fp12"][7] = getBignum(); |
2371 | 0 | parameters["fp12"][8] = getBignum(); |
2372 | 0 | parameters["fp12"][9] = getBignum(); |
2373 | 0 | parameters["fp12"][10] = getBignum(); |
2374 | 0 | parameters["fp12"][11] = getBignum(); |
2375 | 0 | } |
2376 | |
|
2377 | 0 | cryptofuzz::operation::BLS_FinalExp op(parameters); |
2378 | 0 | op.Serialize(dsOut2); |
2379 | 0 | } |
2380 | 0 | break; |
2381 | 0 | case CF_OPERATION("BLS_G1_Add"): |
2382 | 0 | { |
2383 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2384 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2385 | |
|
2386 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2387 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2388 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g1_x); |
2389 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g1_y); |
2390 | 0 | } else { |
2391 | 0 | parameters["a_x"] = getBignum(); |
2392 | 0 | parameters["a_y"] = getBignum(); |
2393 | 0 | } |
2394 | |
|
2395 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2396 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2397 | 0 | parameters["b_x"] = GET_OR_BIGNUM(P.g1_x); |
2398 | 0 | parameters["b_y"] = GET_OR_BIGNUM(P.g1_y); |
2399 | 0 | } else { |
2400 | 0 | parameters["b_x"] = getBignum(); |
2401 | 0 | parameters["b_y"] = getBignum(); |
2402 | 0 | } |
2403 | |
|
2404 | 0 | cryptofuzz::operation::BLS_G1_Add op(parameters); |
2405 | 0 | op.Serialize(dsOut2); |
2406 | |
|
2407 | 0 | generateECCPoint(); |
2408 | 0 | } |
2409 | 0 | break; |
2410 | 0 | case CF_OPERATION("BLS_G1_Mul"): |
2411 | 0 | { |
2412 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2413 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2414 | |
|
2415 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2416 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2417 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g1_x); |
2418 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g1_y); |
2419 | 0 | } else { |
2420 | 0 | parameters["a_x"] = getBignum(); |
2421 | 0 | parameters["a_y"] = getBignum(); |
2422 | 0 | } |
2423 | |
|
2424 | 0 | parameters["b"] = getBignum(); |
2425 | |
|
2426 | 0 | cryptofuzz::operation::BLS_G1_Mul op(parameters); |
2427 | 0 | op.Serialize(dsOut2); |
2428 | |
|
2429 | 0 | generateECCPoint(); |
2430 | 0 | } |
2431 | 0 | break; |
2432 | 0 | case CF_OPERATION("BLS_G1_IsEq"): |
2433 | 0 | { |
2434 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2435 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2436 | |
|
2437 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2438 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2439 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g1_x); |
2440 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g1_y); |
2441 | 0 | } else { |
2442 | 0 | parameters["a_x"] = getBignum(); |
2443 | 0 | parameters["a_y"] = getBignum(); |
2444 | 0 | } |
2445 | |
|
2446 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2447 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2448 | 0 | parameters["b_x"] = GET_OR_BIGNUM(P.g1_x); |
2449 | 0 | parameters["b_y"] = GET_OR_BIGNUM(P.g1_y); |
2450 | 0 | } else { |
2451 | 0 | parameters["b_x"] = getBignum(); |
2452 | 0 | parameters["b_y"] = getBignum(); |
2453 | 0 | } |
2454 | |
|
2455 | 0 | cryptofuzz::operation::BLS_G1_IsEq op(parameters); |
2456 | 0 | op.Serialize(dsOut2); |
2457 | |
|
2458 | 0 | generateECCPoint(); |
2459 | 0 | } |
2460 | 0 | break; |
2461 | 0 | case CF_OPERATION("BLS_G1_Neg"): |
2462 | 0 | { |
2463 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2464 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2465 | |
|
2466 | 0 | if ( getBool() && Pool_CurveBLSG1.Have() == true ) { |
2467 | 0 | const auto P = Pool_CurveBLSG1.Get(); |
2468 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g1_x); |
2469 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g1_y); |
2470 | 0 | } else { |
2471 | 0 | parameters["a_x"] = getBignum(); |
2472 | 0 | parameters["a_y"] = getBignum(); |
2473 | 0 | } |
2474 | |
|
2475 | 0 | cryptofuzz::operation::BLS_G1_Neg op(parameters); |
2476 | 0 | op.Serialize(dsOut2); |
2477 | |
|
2478 | 0 | generateECCPoint(); |
2479 | 0 | } |
2480 | 0 | break; |
2481 | 0 | case CF_OPERATION("BLS_G2_Add"): |
2482 | 0 | { |
2483 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2484 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2485 | |
|
2486 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2487 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2488 | 0 | parameters["a_v"] = GET_OR_BIGNUM(P.g2_v); |
2489 | 0 | parameters["a_w"] = GET_OR_BIGNUM(P.g2_w); |
2490 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g2_x); |
2491 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g2_y); |
2492 | 0 | } else { |
2493 | 0 | parameters["a_v"] = getBignum(); |
2494 | 0 | parameters["a_w"] = getBignum(); |
2495 | 0 | parameters["a_x"] = getBignum(); |
2496 | 0 | parameters["a_y"] = getBignum(); |
2497 | 0 | } |
2498 | |
|
2499 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2500 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2501 | 0 | parameters["b_v"] = GET_OR_BIGNUM(P.g2_v); |
2502 | 0 | parameters["b_w"] = GET_OR_BIGNUM(P.g2_w); |
2503 | 0 | parameters["b_x"] = GET_OR_BIGNUM(P.g2_x); |
2504 | 0 | parameters["b_y"] = GET_OR_BIGNUM(P.g2_y); |
2505 | 0 | } else { |
2506 | 0 | parameters["b_v"] = getBignum(); |
2507 | 0 | parameters["b_w"] = getBignum(); |
2508 | 0 | parameters["b_x"] = getBignum(); |
2509 | 0 | parameters["b_y"] = getBignum(); |
2510 | 0 | } |
2511 | |
|
2512 | 0 | cryptofuzz::operation::BLS_G2_Add op(parameters); |
2513 | 0 | op.Serialize(dsOut2); |
2514 | 0 | } |
2515 | 0 | break; |
2516 | 0 | case CF_OPERATION("BLS_G2_Mul"): |
2517 | 0 | { |
2518 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2519 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2520 | |
|
2521 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2522 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2523 | 0 | parameters["a_v"] = GET_OR_BIGNUM(P.g2_v); |
2524 | 0 | parameters["a_w"] = GET_OR_BIGNUM(P.g2_w); |
2525 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g2_x); |
2526 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g2_y); |
2527 | 0 | } else { |
2528 | 0 | parameters["a_v"] = getBignum(); |
2529 | 0 | parameters["a_w"] = getBignum(); |
2530 | 0 | parameters["a_x"] = getBignum(); |
2531 | 0 | parameters["a_y"] = getBignum(); |
2532 | 0 | } |
2533 | |
|
2534 | 0 | parameters["b"] = getBignum(); |
2535 | |
|
2536 | 0 | cryptofuzz::operation::BLS_G2_Mul op(parameters); |
2537 | 0 | op.Serialize(dsOut2); |
2538 | 0 | } |
2539 | 0 | break; |
2540 | 0 | case CF_OPERATION("BLS_G2_IsEq"): |
2541 | 0 | { |
2542 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2543 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2544 | |
|
2545 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2546 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2547 | 0 | parameters["a_v"] = GET_OR_BIGNUM(P.g2_v); |
2548 | 0 | parameters["a_w"] = GET_OR_BIGNUM(P.g2_w); |
2549 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g2_x); |
2550 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g2_y); |
2551 | 0 | } else { |
2552 | 0 | parameters["a_v"] = getBignum(); |
2553 | 0 | parameters["a_w"] = getBignum(); |
2554 | 0 | parameters["a_x"] = getBignum(); |
2555 | 0 | parameters["a_y"] = getBignum(); |
2556 | 0 | } |
2557 | |
|
2558 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2559 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2560 | 0 | parameters["b_v"] = GET_OR_BIGNUM(P.g2_v); |
2561 | 0 | parameters["b_w"] = GET_OR_BIGNUM(P.g2_w); |
2562 | 0 | parameters["b_x"] = GET_OR_BIGNUM(P.g2_x); |
2563 | 0 | parameters["b_y"] = GET_OR_BIGNUM(P.g2_y); |
2564 | 0 | } else { |
2565 | 0 | parameters["b_v"] = getBignum(); |
2566 | 0 | parameters["b_w"] = getBignum(); |
2567 | 0 | parameters["b_x"] = getBignum(); |
2568 | 0 | parameters["b_y"] = getBignum(); |
2569 | 0 | } |
2570 | |
|
2571 | 0 | cryptofuzz::operation::BLS_G2_IsEq op(parameters); |
2572 | 0 | op.Serialize(dsOut2); |
2573 | 0 | } |
2574 | 0 | break; |
2575 | 0 | case CF_OPERATION("BLS_G2_Neg"): |
2576 | 0 | { |
2577 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1000); |
2578 | 0 | parameters["curveType"] = hint_ecc_mont(getRandomCurve()); |
2579 | |
|
2580 | 0 | if ( getBool() && Pool_CurveBLSG2.Have() == true ) { |
2581 | 0 | const auto P = Pool_CurveBLSG2.Get(); |
2582 | 0 | parameters["a_v"] = GET_OR_BIGNUM(P.g2_v); |
2583 | 0 | parameters["a_w"] = GET_OR_BIGNUM(P.g2_w); |
2584 | 0 | parameters["a_x"] = GET_OR_BIGNUM(P.g2_x); |
2585 | 0 | parameters["a_y"] = GET_OR_BIGNUM(P.g2_y); |
2586 | 0 | } else { |
2587 | 0 | parameters["a_v"] = getBignum(); |
2588 | 0 | parameters["a_w"] = getBignum(); |
2589 | 0 | parameters["a_x"] = getBignum(); |
2590 | 0 | parameters["a_y"] = getBignum(); |
2591 | 0 | } |
2592 | |
|
2593 | 0 | cryptofuzz::operation::BLS_G2_Neg op(parameters); |
2594 | 0 | op.Serialize(dsOut2); |
2595 | 0 | } |
2596 | 0 | break; |
2597 | 0 | case CF_OPERATION("SR25519_Verify"): |
2598 | 0 | { |
2599 | 0 | parameters["modifier"] = getBuffer(PRNG() % 1024); |
2600 | |
|
2601 | 0 | parameters["signature"]["pub"] = getBignum(); |
2602 | |
|
2603 | 0 | parameters["signature"]["signature"][0] = getBignum(); |
2604 | 0 | parameters["signature"]["signature"][1] = getBignum(); |
2605 | |
|
2606 | 0 | parameters["cleartext"] = cryptofuzz::util::DecToHex(getBignum(true), (PRNG() % 64) * 2); |
2607 | |
|
2608 | 0 | cryptofuzz::operation::SR25519_Verify op(parameters); |
2609 | 0 | op.Serialize(dsOut2); |
2610 | 0 | } |
2611 | 0 | break; |
2612 | 0 | default: |
2613 | 0 | goto end; |
2614 | 0 | } |
2615 | 0 | #undef GET_OR_BIGNUM |
2616 | | |
2617 | 0 | fuzzing::datasource::Datasource dsOut(nullptr, 0); |
2618 | | |
2619 | | /* Operation ID */ |
2620 | 0 | dsOut.Put<uint64_t>(operation); |
2621 | |
|
2622 | 0 | dsOut.PutData(dsOut2.GetOut()); |
2623 | | |
2624 | | /* Modifier */ |
2625 | 0 | if ( reuseModifier == true && !modifier.empty() ) { |
2626 | 0 | dsOut.PutData(modifier); |
2627 | 0 | } else { |
2628 | 0 | size_t modifierMaxSize = maxSize / 10; |
2629 | 0 | if ( modifierMaxSize == 0 ) { |
2630 | 0 | modifierMaxSize = 1; |
2631 | 0 | } |
2632 | |
|
2633 | 0 | dsOut.PutData(getBufferBin(PRNG() % modifierMaxSize)); |
2634 | 0 | } |
2635 | | |
2636 | | /* Module ID */ |
2637 | 0 | dsOut.Put<uint64_t>( ModuleLUT[ PRNG() % (sizeof(ModuleLUT) / sizeof(ModuleLUT[0])) ].id ); |
2638 | | |
2639 | | /* Terminator */ |
2640 | 0 | dsOut.Put<bool>(false); |
2641 | |
|
2642 | 0 | const auto insertSize = dsOut.GetOut().size(); |
2643 | 0 | if ( insertSize <= maxSize ) { |
2644 | 0 | memcpy(data, dsOut.GetOut().data(), insertSize); |
2645 | |
|
2646 | 0 | if ( getBool() == true ) { |
2647 | 0 | return insertSize; |
2648 | 0 | } |
2649 | | |
2650 | | /* Fall through to LLVMFuzzerMutate */ |
2651 | 0 | } |
2652 | 0 | } |
2653 | | |
2654 | 0 | end: |
2655 | 0 | return LLVMFuzzerMutate(data, size, maxSize); |
2656 | 0 | } |