Coverage Report

Created: 2022-08-24 06:26

/src/cryptofuzz-sp-math/executor.cpp
Line
Count
Source (jump to first uncovered line)
1
#include "executor.h"
2
#include "tests.h"
3
#include "mutatorpool.h"
4
#include "config.h"
5
#include <cryptofuzz/util.h>
6
#include <fuzzing/memory.hpp>
7
#include <algorithm>
8
#include <set>
9
#include <boost/multiprecision/cpp_int.hpp>
10
11
uint32_t PRNG(void);
12
13
55.5k
#define RETURN_IF_DISABLED(option, id) if ( !option.Have(id) ) return std::nullopt;
14
15
namespace cryptofuzz {
16
17
0
static std::string GxCoordMutate(const uint64_t curveID, std::string coord) {
18
0
    if ( (PRNG()%10) != 0 ) {
19
0
        return coord;
20
0
    }
21
22
0
    if ( curveID == CF_ECC_CURVE("BLS12_381") ) {
23
0
        const static auto prime = boost::multiprecision::cpp_int("4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787");
24
0
        return boost::multiprecision::cpp_int(boost::multiprecision::cpp_int(coord) + prime).str();
25
0
    } else if ( curveID == CF_ECC_CURVE("alt_bn128") ) {
26
0
        const static auto prime = boost::multiprecision::cpp_int("21888242871839275222246405745257275088696311157297823662689037894645226208583");
27
0
        return boost::multiprecision::cpp_int(boost::multiprecision::cpp_int(coord) + prime).str();
28
0
    } else {
29
0
        return coord;
30
0
    }
31
0
}
32
0
static void G1AddToPool(const uint64_t curveID, const std::string& g1_x, const std::string& g1_y) {
33
0
    Pool_CurveBLSG1.Set({ curveID, GxCoordMutate(curveID, g1_x), GxCoordMutate(curveID, g1_y) });
34
0
}
35
36
static void G2AddToPool(const uint64_t curveID,
37
                        const std::string& g2_v,
38
                        const std::string& g2_w,
39
                        const std::string& g2_x,
40
0
                        const std::string& g2_y) {
41
42
0
    Pool_CurveBLSG2.Set({ curveID,
43
0
                                    GxCoordMutate(curveID, g2_v),
44
0
                                    GxCoordMutate(curveID, g2_w),
45
0
                                    GxCoordMutate(curveID, g2_x),
46
0
                                    GxCoordMutate(curveID, g2_y)
47
0
    });
48
0
}
49
50
/* Specialization for operation::Digest */
51
0
template<> void ExecutorBase<component::Digest, operation::Digest>::postprocess(std::shared_ptr<Module> module, operation::Digest& op, const ExecutorBase<component::Digest, operation::Digest>::ResultPair& result) const {
52
0
    (void)module;
53
0
    (void)op;
54
55
0
    if ( result.second != std::nullopt ) {
56
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
57
0
    }
58
0
}
59
60
0
template<> std::optional<component::Digest> ExecutorBase<component::Digest, operation::Digest>::callModule(std::shared_ptr<Module> module, operation::Digest& op) const {
61
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
62
63
0
    return module->OpDigest(op);
64
0
}
65
66
/* Specialization for operation::HMAC */
67
0
template<> void ExecutorBase<component::MAC, operation::HMAC>::postprocess(std::shared_ptr<Module> module, operation::HMAC& op, const ExecutorBase<component::MAC, operation::HMAC>::ResultPair& result) const {
68
0
    (void)module;
69
0
    (void)op;
70
71
0
    if ( result.second != std::nullopt ) {
72
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
73
0
    }
74
0
}
75
76
0
template<> std::optional<component::MAC> ExecutorBase<component::MAC, operation::HMAC>::callModule(std::shared_ptr<Module> module, operation::HMAC& op) const {
77
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
78
79
0
    return module->OpHMAC(op);
80
0
}
81
82
/* Specialization for operation::UMAC */
83
0
template<> void ExecutorBase<component::MAC, operation::UMAC>::postprocess(std::shared_ptr<Module> module, operation::UMAC& op, const ExecutorBase<component::MAC, operation::UMAC>::ResultPair& result) const {
84
0
    (void)module;
85
0
    (void)op;
86
87
0
    if ( result.second != std::nullopt ) {
88
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
89
0
    }
90
0
}
91
92
0
template<> std::optional<component::MAC> ExecutorBase<component::MAC, operation::UMAC>::callModule(std::shared_ptr<Module> module, operation::UMAC& op) const {
93
0
    return module->OpUMAC(op);
94
0
}
95
96
/* Specialization for operation::CMAC */
97
0
template<> void ExecutorBase<component::MAC, operation::CMAC>::postprocess(std::shared_ptr<Module> module, operation::CMAC& op, const ExecutorBase<component::MAC, operation::CMAC>::ResultPair& result) const {
98
0
    (void)module;
99
0
    (void)op;
100
101
0
    if ( result.second != std::nullopt ) {
102
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
103
0
    }
104
0
}
105
106
0
template<> std::optional<component::MAC> ExecutorBase<component::MAC, operation::CMAC>::callModule(std::shared_ptr<Module> module, operation::CMAC& op) const {
107
0
    RETURN_IF_DISABLED(options.ciphers, op.cipher.cipherType.Get());
108
109
0
    return module->OpCMAC(op);
110
0
}
111
112
/* Specialization for operation::SymmetricEncrypt */
113
0
template<> void ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>::postprocess(std::shared_ptr<Module> module, operation::SymmetricEncrypt& op, const ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>::ResultPair& result) const {
114
0
    if ( options.noDecrypt == true ) {
115
0
        return;
116
0
    }
117
118
0
    if ( result.second != std::nullopt ) {
119
0
        fuzzing::memory::memory_test_msan(result.second->ciphertext.GetPtr(), result.second->ciphertext.GetSize());
120
0
        if ( result.second->tag != std::nullopt ) {
121
0
            fuzzing::memory::memory_test_msan(result.second->tag->GetPtr(), result.second->tag->GetSize());
122
0
        }
123
0
    }
124
125
0
    if ( op.cleartext.GetSize() > 0 && result.second != std::nullopt && result.second->ciphertext.GetSize() > 0 ) {
126
0
        using fuzzing::datasource::ID;
127
128
0
        bool tryDecrypt = true;
129
130
0
        if ( module->ID == CF_MODULE("OpenSSL") ) {
131
0
            switch ( op.cipher.cipherType.Get() ) {
132
0
                case    ID("Cryptofuzz/Cipher/AES_128_OCB"):
133
0
                case    ID("Cryptofuzz/Cipher/AES_256_OCB"):
134
0
                    tryDecrypt = false;
135
0
                    break;
136
0
                case    ID("Cryptofuzz/Cipher/AES_128_GCM"):
137
0
                case    ID("Cryptofuzz/Cipher/AES_192_GCM"):
138
0
                case    ID("Cryptofuzz/Cipher/AES_256_GCM"):
139
0
                case    ID("Cryptofuzz/Cipher/AES_128_CCM"):
140
0
                case    ID("Cryptofuzz/Cipher/AES_192_CCM"):
141
0
                case    ID("Cryptofuzz/Cipher/AES_256_CCM"):
142
0
                case    ID("Cryptofuzz/Cipher/ARIA_128_CCM"):
143
0
                case    ID("Cryptofuzz/Cipher/ARIA_192_CCM"):
144
0
                case    ID("Cryptofuzz/Cipher/ARIA_256_CCM"):
145
0
                case    ID("Cryptofuzz/Cipher/ARIA_128_GCM"):
146
0
                case    ID("Cryptofuzz/Cipher/ARIA_192_GCM"):
147
0
                case    ID("Cryptofuzz/Cipher/ARIA_256_GCM"):
148
0
                    if ( op.tagSize == std::nullopt ) {
149
                        /* OpenSSL fails to decrypt its own CCM and GCM ciphertexts if
150
                         * a tag is not included
151
                         */
152
0
                        tryDecrypt = false;
153
0
                    }
154
0
                    break;
155
0
            }
156
0
        }
157
158
0
        if ( tryDecrypt == true ) {
159
            /* Try to decrypt the encrypted data */
160
161
            /* Construct a SymmetricDecrypt instance with the SymmetricEncrypt instance */
162
0
            auto opDecrypt = operation::SymmetricDecrypt(
163
                    /* The SymmetricEncrypt instance */
164
0
                    op,
165
166
                    /* The ciphertext generated by OpSymmetricEncrypt */
167
0
                    *(result.second),
168
169
                    /* The size of the output buffer that OpSymmetricDecrypt() must use. */
170
0
                    op.cleartext.GetSize() + 32,
171
172
0
                    op.aad,
173
174
                    /* Empty modifier */
175
0
                    {});
176
177
0
            const auto cleartext = module->OpSymmetricDecrypt(opDecrypt);
178
179
0
            if ( cleartext == std::nullopt ) {
180
                /* Decryption failed, OpSymmetricDecrypt() returned std::nullopt */
181
0
                printf("Cannot decrypt ciphertext\n\n");
182
0
                printf("Operation:\n%s\n", op.ToString().c_str());
183
0
                printf("Ciphertext: %s\n", util::HexDump(result.second->ciphertext.Get()).c_str());
184
0
                printf("Tag: %s\n", result.second->tag ? util::HexDump(result.second->tag->Get()).c_str() : "nullopt");
185
0
                abort(
186
0
                        {module->name},
187
0
                        op.Name(),
188
0
                        op.GetAlgorithmString(),
189
0
                        "cannot decrypt ciphertext"
190
0
                );
191
0
            } else if ( cleartext->Get() != op.cleartext.Get() ) {
192
                /* Decryption ostensibly succeeded, but the cleartext returned by OpSymmetricDecrypt()
193
                 * does not match to original cleartext */
194
195
0
                printf("Cannot decrypt ciphertext (but decryption ostensibly succeeded)\n\n");
196
0
                printf("Operation:\n%s\n", op.ToString().c_str());
197
0
                printf("Ciphertext: %s\n", util::HexDump(result.second->ciphertext.Get()).c_str());
198
0
                printf("Tag: %s\n", result.second->tag ? util::HexDump(result.second->tag->Get()).c_str() : "nullopt");
199
0
                printf("Purported cleartext: %s\n", util::HexDump(cleartext->Get()).c_str());
200
0
                abort(
201
0
                        {module->name},
202
0
                        op.Name(),
203
0
                        op.GetAlgorithmString(),
204
0
                        "cannot decrypt ciphertext"
205
0
                );
206
0
            }
207
0
        }
208
0
    }
209
0
}
210
211
0
template<> std::optional<component::Ciphertext> ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>::callModule(std::shared_ptr<Module> module, operation::SymmetricEncrypt& op) const {
212
0
    RETURN_IF_DISABLED(options.ciphers , op.cipher.cipherType.Get());
213
214
0
    return module->OpSymmetricEncrypt(op);
215
0
}
216
217
/* Specialization for operation::SymmetricDecrypt */
218
0
template<> void ExecutorBase<component::MAC, operation::SymmetricDecrypt>::postprocess(std::shared_ptr<Module> module, operation::SymmetricDecrypt& op, const ExecutorBase<component::MAC, operation::SymmetricDecrypt>::ResultPair& result) const {
219
0
    (void)module;
220
0
    (void)op;
221
222
0
    if ( result.second != std::nullopt ) {
223
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
224
0
    }
225
0
}
226
227
0
template<> std::optional<component::MAC> ExecutorBase<component::MAC, operation::SymmetricDecrypt>::callModule(std::shared_ptr<Module> module, operation::SymmetricDecrypt& op) const {
228
0
    RETURN_IF_DISABLED(options.ciphers , op.cipher.cipherType.Get());
229
230
0
    return module->OpSymmetricDecrypt(op);
231
0
}
232
233
/* Specialization for operation::KDF_SCRYPT */
234
0
template<> void ExecutorBase<component::Key, operation::KDF_SCRYPT>::postprocess(std::shared_ptr<Module> module, operation::KDF_SCRYPT& op, const ExecutorBase<component::Key, operation::KDF_SCRYPT>::ResultPair& result) const {
235
0
    (void)module;
236
0
    (void)op;
237
238
0
    if ( result.second != std::nullopt ) {
239
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
240
0
    }
241
0
}
242
243
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_SCRYPT>::callModule(std::shared_ptr<Module> module, operation::KDF_SCRYPT& op) const {
244
0
    return module->OpKDF_SCRYPT(op);
245
0
}
246
247
/* Specialization for operation::KDF_HKDF */
248
0
template<> void ExecutorBase<component::Key, operation::KDF_HKDF>::postprocess(std::shared_ptr<Module> module, operation::KDF_HKDF& op, const ExecutorBase<component::Key, operation::KDF_HKDF>::ResultPair& result) const {
249
0
    (void)module;
250
0
    (void)op;
251
252
0
    if ( result.second != std::nullopt ) {
253
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
254
0
    }
255
0
}
256
257
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_HKDF>::callModule(std::shared_ptr<Module> module, operation::KDF_HKDF& op) const {
258
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
259
260
0
    return module->OpKDF_HKDF(op);
261
0
}
262
263
/* Specialization for operation::KDF_PBKDF */
264
0
template<> void ExecutorBase<component::Key, operation::KDF_PBKDF>::postprocess(std::shared_ptr<Module> module, operation::KDF_PBKDF& op, const ExecutorBase<component::Key, operation::KDF_PBKDF>::ResultPair& result) const {
265
0
    (void)module;
266
0
    (void)op;
267
268
0
    if ( result.second != std::nullopt ) {
269
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
270
0
    }
271
0
}
272
273
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_PBKDF>::callModule(std::shared_ptr<Module> module, operation::KDF_PBKDF& op) const {
274
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
275
276
0
    return module->OpKDF_PBKDF(op);
277
0
}
278
279
/* Specialization for operation::KDF_PBKDF1 */
280
0
template<> void ExecutorBase<component::Key, operation::KDF_PBKDF1>::postprocess(std::shared_ptr<Module> module, operation::KDF_PBKDF1& op, const ExecutorBase<component::Key, operation::KDF_PBKDF1>::ResultPair& result) const {
281
0
    (void)module;
282
0
    (void)op;
283
284
0
    if ( result.second != std::nullopt ) {
285
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
286
0
    }
287
0
}
288
289
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_PBKDF1>::callModule(std::shared_ptr<Module> module, operation::KDF_PBKDF1& op) const {
290
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
291
292
0
    return module->OpKDF_PBKDF1(op);
293
0
}
294
295
/* Specialization for operation::KDF_PBKDF2 */
296
0
template<> void ExecutorBase<component::Key, operation::KDF_PBKDF2>::postprocess(std::shared_ptr<Module> module, operation::KDF_PBKDF2& op, const ExecutorBase<component::Key, operation::KDF_PBKDF2>::ResultPair& result) const {
297
0
    (void)module;
298
0
    (void)op;
299
300
0
    if ( result.second != std::nullopt ) {
301
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
302
0
    }
303
0
}
304
305
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_PBKDF2>::callModule(std::shared_ptr<Module> module, operation::KDF_PBKDF2& op) const {
306
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
307
308
0
    return module->OpKDF_PBKDF2(op);
309
0
}
310
311
/* Specialization for operation::KDF_ARGON2 */
312
0
template<> void ExecutorBase<component::Key, operation::KDF_ARGON2>::postprocess(std::shared_ptr<Module> module, operation::KDF_ARGON2& op, const ExecutorBase<component::Key, operation::KDF_ARGON2>::ResultPair& result) const {
313
0
    (void)module;
314
0
    (void)op;
315
316
0
    if ( result.second != std::nullopt ) {
317
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
318
0
    }
319
0
}
320
321
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_ARGON2>::callModule(std::shared_ptr<Module> module, operation::KDF_ARGON2& op) const {
322
0
    return module->OpKDF_ARGON2(op);
323
0
}
324
325
/* Specialization for operation::KDF_SSH */
326
0
template<> void ExecutorBase<component::Key, operation::KDF_SSH>::postprocess(std::shared_ptr<Module> module, operation::KDF_SSH& op, const ExecutorBase<component::Key, operation::KDF_SSH>::ResultPair& result) const {
327
0
    (void)module;
328
0
    (void)op;
329
330
0
    if ( result.second != std::nullopt ) {
331
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
332
0
    }
333
0
}
334
335
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_SSH>::callModule(std::shared_ptr<Module> module, operation::KDF_SSH& op) const {
336
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
337
338
0
    return module->OpKDF_SSH(op);
339
0
}
340
341
/* Specialization for operation::KDF_TLS1_PRF */
342
0
template<> void ExecutorBase<component::Key, operation::KDF_TLS1_PRF>::postprocess(std::shared_ptr<Module> module, operation::KDF_TLS1_PRF& op, const ExecutorBase<component::Key, operation::KDF_TLS1_PRF>::ResultPair& result) const {
343
0
    (void)module;
344
0
    (void)op;
345
346
0
    if ( result.second != std::nullopt ) {
347
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
348
0
    }
349
0
}
350
351
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_TLS1_PRF>::callModule(std::shared_ptr<Module> module, operation::KDF_TLS1_PRF& op) const {
352
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
353
354
0
    return module->OpKDF_TLS1_PRF(op);
355
0
}
356
357
/* Specialization for operation::KDF_X963 */
358
0
template<> void ExecutorBase<component::Key, operation::KDF_X963>::postprocess(std::shared_ptr<Module> module, operation::KDF_X963& op, const ExecutorBase<component::Key, operation::KDF_X963>::ResultPair& result) const {
359
0
    (void)module;
360
0
    (void)op;
361
362
0
    if ( result.second != std::nullopt ) {
363
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
364
0
    }
365
0
}
366
367
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_X963>::callModule(std::shared_ptr<Module> module, operation::KDF_X963& op) const {
368
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
369
370
0
    return module->OpKDF_X963(op);
371
0
}
372
373
/* Specialization for operation::KDF_BCRYPT */
374
0
template<> void ExecutorBase<component::Key, operation::KDF_BCRYPT>::postprocess(std::shared_ptr<Module> module, operation::KDF_BCRYPT& op, const ExecutorBase<component::Key, operation::KDF_BCRYPT>::ResultPair& result) const {
375
0
    (void)module;
376
0
    (void)op;
377
378
0
    if ( result.second != std::nullopt ) {
379
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
380
0
    }
381
0
}
382
383
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_BCRYPT>::callModule(std::shared_ptr<Module> module, operation::KDF_BCRYPT& op) const {
384
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
385
386
0
    return module->OpKDF_BCRYPT(op);
387
0
}
388
389
/* Specialization for operation::KDF_SP_800_108 */
390
0
template<> void ExecutorBase<component::Key, operation::KDF_SP_800_108>::postprocess(std::shared_ptr<Module> module, operation::KDF_SP_800_108& op, const ExecutorBase<component::Key, operation::KDF_SP_800_108>::ResultPair& result) const {
391
0
    (void)module;
392
0
    (void)op;
393
394
0
    if ( result.second != std::nullopt ) {
395
0
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
396
0
    }
397
0
}
398
399
0
template<> std::optional<component::Key> ExecutorBase<component::Key, operation::KDF_SP_800_108>::callModule(std::shared_ptr<Module> module, operation::KDF_SP_800_108& op) const {
400
0
    if ( op.mech.mode == true ) {
401
0
        RETURN_IF_DISABLED(options.digests, op.mech.type.Get());
402
0
    }
403
404
0
    return module->OpKDF_SP_800_108(op);
405
0
}
406
407
408
/* Specialization for operation::ECC_PrivateToPublic */
409
2.67k
template<> void ExecutorBase<component::ECC_PublicKey, operation::ECC_PrivateToPublic>::postprocess(std::shared_ptr<Module> module, operation::ECC_PrivateToPublic& op, const ExecutorBase<component::ECC_PublicKey, operation::ECC_PrivateToPublic>::ResultPair& result) const {
410
2.67k
    (void)module;
411
412
2.67k
    if ( result.second != std::nullopt  ) {
413
1.16k
        const auto curveID = op.curveType.Get();
414
1.16k
        const auto privkey = op.priv.ToTrimmedString();
415
1.16k
        const auto pub_x = result.second->first.ToTrimmedString();
416
1.16k
        const auto pub_y = result.second->second.ToTrimmedString();
417
418
1.16k
        Pool_CurvePrivkey.Set({ curveID, privkey });
419
1.16k
        Pool_CurveKeypair.Set({ curveID, privkey, pub_x, pub_y });
420
1.16k
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
421
422
1.16k
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
423
1.16k
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
424
1.16k
    }
425
2.67k
}
426
427
2.67k
template<> std::optional<component::ECC_PublicKey> ExecutorBase<component::ECC_PublicKey, operation::ECC_PrivateToPublic>::callModule(std::shared_ptr<Module> module, operation::ECC_PrivateToPublic& op) const {
428
2.67k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
429
430
2.67k
    const size_t size = op.priv.ToTrimmedString().size();
431
432
2.67k
    if ( size == 0 || size > 4096 ) {
433
27
        return std::nullopt;
434
27
    }
435
436
2.64k
    return module->OpECC_PrivateToPublic(op);
437
2.67k
}
438
439
/* Specialization for operation::ECC_ValidatePubkey */
440
2.42k
template<> void ExecutorBase<bool, operation::ECC_ValidatePubkey>::postprocess(std::shared_ptr<Module> module, operation::ECC_ValidatePubkey& op, const ExecutorBase<bool, operation::ECC_ValidatePubkey>::ResultPair& result) const {
441
2.42k
    (void)module;
442
2.42k
    (void)op;
443
2.42k
    (void)result;
444
2.42k
}
445
446
2.42k
template<> std::optional<bool> ExecutorBase<bool, operation::ECC_ValidatePubkey>::callModule(std::shared_ptr<Module> module, operation::ECC_ValidatePubkey& op) const {
447
2.42k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
448
449
2.42k
    return module->OpECC_ValidatePubkey(op);
450
2.42k
}
451
452
/* Specialization for operation::ECC_GenerateKeyPair */
453
454
/* Do not compare DH_GenerateKeyPair results, because the result can be produced indeterministically */
455
template <>
456
668
void ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::DH_GenerateKeyPair> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
457
668
    (void)operations;
458
668
    (void)results;
459
668
    (void)data;
460
668
    (void)size;
461
668
}
462
463
3.18k
template<> void ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>::postprocess(std::shared_ptr<Module> module, operation::ECC_GenerateKeyPair& op, const ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>::ResultPair& result) const {
464
3.18k
    (void)module;
465
466
3.18k
    if ( result.second != std::nullopt  ) {
467
1.33k
        const auto curveID = op.curveType.Get();
468
1.33k
        const auto privkey = result.second->priv.ToTrimmedString();
469
1.33k
        const auto pub_x = result.second->pub.first.ToTrimmedString();
470
1.33k
        const auto pub_y = result.second->pub.second.ToTrimmedString();
471
472
1.33k
        Pool_CurvePrivkey.Set({ curveID, privkey });
473
1.33k
        Pool_CurveKeypair.Set({ curveID, privkey, pub_x, pub_y });
474
1.33k
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
475
1.33k
    }
476
3.18k
}
477
478
3.18k
template<> std::optional<component::ECC_KeyPair> ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>::callModule(std::shared_ptr<Module> module, operation::ECC_GenerateKeyPair& op) const {
479
3.18k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
480
481
3.18k
    return module->OpECC_GenerateKeyPair(op);
482
3.18k
}
483
484
/* Specialization for operation::ECDSA_Sign */
485
4.33k
template<> void ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::postprocess(std::shared_ptr<Module> module, operation::ECDSA_Sign& op, const ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::ResultPair& result) const {
486
4.33k
    (void)module;
487
488
4.33k
    if ( result.second != std::nullopt  ) {
489
2.14k
        const auto curveID = op.curveType.Get();
490
2.14k
        const auto cleartext = op.cleartext.ToHex();
491
2.14k
        const auto pub_x = result.second->pub.first.ToTrimmedString();
492
2.14k
        const auto pub_y = result.second->pub.second.ToTrimmedString();
493
2.14k
        const auto sig_r = result.second->signature.first.ToTrimmedString();
494
2.14k
        const auto sig_s = result.second->signature.second.ToTrimmedString();
495
496
2.14k
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
497
2.14k
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
498
2.14k
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
499
500
2.14k
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
501
2.14k
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
502
2.14k
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
503
2.14k
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
504
505
2.14k
        {
506
2.14k
            auto opVerify = operation::ECDSA_Verify(
507
2.14k
                    op,
508
2.14k
                    *(result.second),
509
2.14k
                    op.modifier);
510
511
2.14k
            const auto verifyResult = module->OpECDSA_Verify(opVerify);
512
2.14k
            CF_ASSERT(
513
2.14k
                    verifyResult == std::nullopt ||
514
2.14k
                    *verifyResult == true,
515
2.14k
                    "Cannot verify generated signature");
516
2.14k
        }
517
2.14k
    }
518
4.33k
}
519
520
4.33k
template<> std::optional<component::ECDSA_Signature> ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECDSA_Sign& op) const {
521
4.33k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
522
4.33k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
523
524
4.19k
    const size_t size = op.priv.ToTrimmedString().size();
525
526
4.19k
    if ( size == 0 || size > 4096 ) {
527
0
        return std::nullopt;
528
0
    }
529
530
4.19k
    return module->OpECDSA_Sign(op);
531
4.19k
}
532
533
/* Specialization for operation::ECGDSA_Sign */
534
0
template<> void ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::postprocess(std::shared_ptr<Module> module, operation::ECGDSA_Sign& op, const ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::ResultPair& result) const {
535
0
    (void)module;
536
537
0
    if ( result.second != std::nullopt  ) {
538
0
        const auto curveID = op.curveType.Get();
539
0
        const auto cleartext = op.cleartext.ToHex();
540
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
541
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
542
0
        const auto sig_r = result.second->signature.first.ToTrimmedString();
543
0
        const auto sig_s = result.second->signature.second.ToTrimmedString();
544
545
0
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
546
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
547
0
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
548
549
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
550
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
551
0
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
552
0
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
553
0
    }
554
0
}
555
556
0
template<> std::optional<component::ECGDSA_Signature> ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECGDSA_Sign& op) const {
557
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
558
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
559
560
0
    const size_t size = op.priv.ToTrimmedString().size();
561
562
0
    if ( size == 0 || size > 4096 ) {
563
0
        return std::nullopt;
564
0
    }
565
566
0
    return module->OpECGDSA_Sign(op);
567
0
}
568
569
/* Specialization for operation::ECRDSA_Sign */
570
0
template<> void ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::postprocess(std::shared_ptr<Module> module, operation::ECRDSA_Sign& op, const ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::ResultPair& result) const {
571
0
    (void)module;
572
573
0
    if ( result.second != std::nullopt  ) {
574
0
        const auto curveID = op.curveType.Get();
575
0
        const auto cleartext = op.cleartext.ToHex();
576
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
577
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
578
0
        const auto sig_r = result.second->signature.first.ToTrimmedString();
579
0
        const auto sig_s = result.second->signature.second.ToTrimmedString();
580
581
0
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
582
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
583
0
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
584
585
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
586
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
587
0
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
588
0
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
589
0
    }
590
0
}
591
592
0
template<> std::optional<component::ECRDSA_Signature> ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECRDSA_Sign& op) const {
593
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
594
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
595
596
0
    const size_t size = op.priv.ToTrimmedString().size();
597
598
0
    if ( size == 0 || size > 4096 ) {
599
0
        return std::nullopt;
600
0
    }
601
602
0
    return module->OpECRDSA_Sign(op);
603
0
}
604
605
/* Specialization for operation::Schnorr_Sign */
606
0
template<> void ExecutorBase<component::Schnorr_Signature, operation::Schnorr_Sign>::postprocess(std::shared_ptr<Module> module, operation::Schnorr_Sign& op, const ExecutorBase<component::Schnorr_Signature, operation::Schnorr_Sign>::ResultPair& result) const {
607
0
    (void)module;
608
609
0
    if ( result.second != std::nullopt  ) {
610
0
        const auto curveID = op.curveType.Get();
611
0
        const auto cleartext = op.cleartext.ToHex();
612
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
613
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
614
0
        const auto sig_r = result.second->signature.first.ToTrimmedString();
615
0
        const auto sig_s = result.second->signature.second.ToTrimmedString();
616
617
0
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
618
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
619
0
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
620
621
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
622
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
623
0
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
624
0
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
625
0
    }
626
0
}
627
628
0
template<> std::optional<component::Schnorr_Signature> ExecutorBase<component::Schnorr_Signature, operation::Schnorr_Sign>::callModule(std::shared_ptr<Module> module, operation::Schnorr_Sign& op) const {
629
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
630
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
631
632
0
    const size_t size = op.priv.ToTrimmedString().size();
633
634
0
    if ( size == 0 || size > 4096 ) {
635
0
        return std::nullopt;
636
0
    }
637
638
0
    return module->OpSchnorr_Sign(op);
639
0
}
640
641
/* Specialization for operation::ECDSA_Verify */
642
1.97k
template<> void ExecutorBase<bool, operation::ECDSA_Verify>::postprocess(std::shared_ptr<Module> module, operation::ECDSA_Verify& op, const ExecutorBase<bool, operation::ECDSA_Verify>::ResultPair& result) const {
643
1.97k
    (void)module;
644
1.97k
    (void)op;
645
1.97k
    (void)result;
646
1.97k
}
647
648
1.97k
template<> std::optional<bool> ExecutorBase<bool, operation::ECDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECDSA_Verify& op) const {
649
1.97k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
650
1.97k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
651
652
    /* Intentionally do not constrain the size of the public key or
653
     * signature (like we do for BignumCalc).
654
     *
655
     * If any large public key or signature causes a time-out (or
656
     * worse), this is something that needs attention;
657
     * because verifiers sometimes process untrusted public keys,
658
     * signatures or both, they should be resistant to bugs
659
     * arising from large inputs.
660
     */
661
662
1.86k
    return module->OpECDSA_Verify(op);
663
1.97k
}
664
665
/* Specialization for operation::ECGDSA_Verify */
666
0
template<> void ExecutorBase<bool, operation::ECGDSA_Verify>::postprocess(std::shared_ptr<Module> module, operation::ECGDSA_Verify& op, const ExecutorBase<bool, operation::ECGDSA_Verify>::ResultPair& result) const {
667
0
    (void)module;
668
0
    (void)op;
669
0
    (void)result;
670
0
}
671
672
0
template<> std::optional<bool> ExecutorBase<bool, operation::ECGDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECGDSA_Verify& op) const {
673
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
674
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
675
676
    /* Intentionally do not constrain the size of the public key or
677
     * signature (like we do for BignumCalc).
678
     *
679
     * If any large public key or signature causes a time-out (or
680
     * worse), this is something that needs attention;
681
     * because verifiers sometimes process untrusted public keys,
682
     * signatures or both, they should be resistant to bugs
683
     * arising from large inputs.
684
     */
685
686
0
    return module->OpECGDSA_Verify(op);
687
0
}
688
689
/* Specialization for operation::ECRDSA_Verify */
690
0
template<> void ExecutorBase<bool, operation::ECRDSA_Verify>::postprocess(std::shared_ptr<Module> module, operation::ECRDSA_Verify& op, const ExecutorBase<bool, operation::ECRDSA_Verify>::ResultPair& result) const {
691
0
    (void)module;
692
0
    (void)op;
693
0
    (void)result;
694
0
}
695
696
0
template<> std::optional<bool> ExecutorBase<bool, operation::ECRDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECRDSA_Verify& op) const {
697
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
698
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
699
700
    /* Intentionally do not constrain the size of the public key or
701
     * signature (like we do for BignumCalc).
702
     *
703
     * If any large public key or signature causes a time-out (or
704
     * worse), this is something that needs attention;
705
     * because verifiers sometimes process untrusted public keys,
706
     * signatures or both, they should be resistant to bugs
707
     * arising from large inputs.
708
     */
709
710
0
    return module->OpECRDSA_Verify(op);
711
0
}
712
713
/* Specialization for operation::Schnorr_Verify */
714
0
template<> void ExecutorBase<bool, operation::Schnorr_Verify>::postprocess(std::shared_ptr<Module> module, operation::Schnorr_Verify& op, const ExecutorBase<bool, operation::Schnorr_Verify>::ResultPair& result) const {
715
0
    (void)module;
716
0
    (void)op;
717
0
    (void)result;
718
0
}
719
720
0
template<> std::optional<bool> ExecutorBase<bool, operation::Schnorr_Verify>::callModule(std::shared_ptr<Module> module, operation::Schnorr_Verify& op) const {
721
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
722
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
723
724
    /* Intentionally do not constrain the size of the public key or
725
     * signature (like we do for BignumCalc).
726
     *
727
     * If any large public key or signature causes a time-out (or
728
     * worse), this is something that needs attention;
729
     * because verifiers sometimes process untrusted public keys,
730
     * signatures or both, they should be resistant to bugs
731
     * arising from large inputs.
732
     */
733
734
0
    return module->OpSchnorr_Verify(op);
735
0
}
736
737
0
template<> void ExecutorBase<component::ECC_PublicKey, operation::ECDSA_Recover>::postprocess(std::shared_ptr<Module> module, operation::ECDSA_Recover& op, const ExecutorBase<component::ECC_PublicKey, operation::ECDSA_Recover>::ResultPair& result) const {
738
0
    (void)module;
739
0
    (void)op;
740
0
    (void)result;
741
0
}
742
743
0
template<> std::optional<component::ECC_PublicKey> ExecutorBase<component::ECC_PublicKey, operation::ECDSA_Recover>::callModule(std::shared_ptr<Module> module, operation::ECDSA_Recover& op) const {
744
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
745
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
746
747
0
    return module->OpECDSA_Recover(op);
748
0
}
749
750
/* Specialization for operation::ECDH_Derive */
751
336
template<> void ExecutorBase<component::Secret, operation::ECDH_Derive>::postprocess(std::shared_ptr<Module> module, operation::ECDH_Derive& op, const ExecutorBase<component::Secret, operation::ECDH_Derive>::ResultPair& result) const {
752
336
    (void)module;
753
336
    (void)op;
754
336
    (void)result;
755
336
}
756
757
336
template<> std::optional<component::Secret> ExecutorBase<component::Secret, operation::ECDH_Derive>::callModule(std::shared_ptr<Module> module, operation::ECDH_Derive& op) const {
758
336
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
759
760
336
    return module->OpECDH_Derive(op);
761
336
}
762
763
/* Specialization for operation::ECIES_Encrypt */
764
657
template<> void ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>::postprocess(std::shared_ptr<Module> module, operation::ECIES_Encrypt& op, const ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>::ResultPair& result) const {
765
657
    (void)module;
766
657
    (void)op;
767
657
    (void)result;
768
657
}
769
770
657
template<> std::optional<component::Ciphertext> ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>::callModule(std::shared_ptr<Module> module, operation::ECIES_Encrypt& op) const {
771
657
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
772
773
657
    return module->OpECIES_Encrypt(op);
774
657
}
775
776
/* Specialization for operation::ECIES_Decrypt */
777
433
template<> void ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>::postprocess(std::shared_ptr<Module> module, operation::ECIES_Decrypt& op, const ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>::ResultPair& result) const {
778
433
    (void)module;
779
433
    (void)op;
780
433
    (void)result;
781
433
}
782
783
433
template<> std::optional<component::Cleartext> ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>::callModule(std::shared_ptr<Module> module, operation::ECIES_Decrypt& op) const {
784
433
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
785
786
433
    return module->OpECIES_Decrypt(op);
787
433
}
788
789
/* Specialization for operation::ECC_Point_Add */
790
1.83k
template<> void ExecutorBase<component::ECC_Point, operation::ECC_Point_Add>::postprocess(std::shared_ptr<Module> module, operation::ECC_Point_Add& op, const ExecutorBase<component::ECC_Point, operation::ECC_Point_Add>::ResultPair& result) const {
791
1.83k
    (void)module;
792
793
1.83k
    if ( result.second != std::nullopt  ) {
794
60
        const auto curveID = op.curveType.Get();
795
60
        const auto x = result.second->first.ToTrimmedString();
796
60
        const auto y = result.second->second.ToTrimmedString();
797
798
60
        Pool_CurveECC_Point.Set({ curveID, x, y });
799
800
60
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
801
60
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
802
60
    }
803
1.83k
}
804
805
1.83k
template<> std::optional<component::ECC_Point> ExecutorBase<component::ECC_Point, operation::ECC_Point_Add>::callModule(std::shared_ptr<Module> module, operation::ECC_Point_Add& op) const {
806
1.83k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
807
808
1.83k
    return module->OpECC_Point_Add(op);
809
1.83k
}
810
811
/* Specialization for operation::ECC_Point_Mul */
812
1.74k
template<> void ExecutorBase<component::ECC_Point, operation::ECC_Point_Mul>::postprocess(std::shared_ptr<Module> module, operation::ECC_Point_Mul& op, const ExecutorBase<component::ECC_Point, operation::ECC_Point_Mul>::ResultPair& result) const {
813
1.74k
    (void)module;
814
815
1.74k
    if ( result.second != std::nullopt  ) {
816
190
        const auto curveID = op.curveType.Get();
817
190
        const auto x = result.second->first.ToTrimmedString();
818
190
        const auto y = result.second->second.ToTrimmedString();
819
820
190
        Pool_CurveECC_Point.Set({ curveID, x, y });
821
822
190
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
823
190
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
824
190
    }
825
1.74k
}
826
827
1.74k
template<> std::optional<component::ECC_Point> ExecutorBase<component::ECC_Point, operation::ECC_Point_Mul>::callModule(std::shared_ptr<Module> module, operation::ECC_Point_Mul& op) const {
828
1.74k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
829
830
1.74k
    return module->OpECC_Point_Mul(op);
831
1.74k
}
832
833
/* Specialization for operation::ECC_Point_Neg */
834
0
template<> void ExecutorBase<component::ECC_Point, operation::ECC_Point_Neg>::postprocess(std::shared_ptr<Module> module, operation::ECC_Point_Neg& op, const ExecutorBase<component::ECC_Point, operation::ECC_Point_Neg>::ResultPair& result) const {
835
0
    (void)module;
836
837
0
    if ( result.second != std::nullopt  ) {
838
0
        const auto curveID = op.curveType.Get();
839
0
        const auto x = result.second->first.ToTrimmedString();
840
0
        const auto y = result.second->second.ToTrimmedString();
841
842
0
        Pool_CurveECC_Point.Set({ curveID, x, y });
843
844
0
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
845
0
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
846
0
    }
847
0
}
848
849
0
template<> std::optional<component::ECC_Point> ExecutorBase<component::ECC_Point, operation::ECC_Point_Neg>::callModule(std::shared_ptr<Module> module, operation::ECC_Point_Neg& op) const {
850
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
851
852
0
    return module->OpECC_Point_Neg(op);
853
0
}
854
855
/* Specialization for operation::ECC_Point_Dbl */
856
0
template<> void ExecutorBase<component::ECC_Point, operation::ECC_Point_Dbl>::postprocess(std::shared_ptr<Module> module, operation::ECC_Point_Dbl& op, const ExecutorBase<component::ECC_Point, operation::ECC_Point_Dbl>::ResultPair& result) const {
857
0
    (void)module;
858
859
0
    if ( result.second != std::nullopt  ) {
860
0
        const auto curveID = op.curveType.Get();
861
0
        const auto x = result.second->first.ToTrimmedString();
862
0
        const auto y = result.second->second.ToTrimmedString();
863
864
0
        Pool_CurveECC_Point.Set({ curveID, x, y });
865
866
0
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
867
0
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
868
0
    }
869
0
}
870
871
0
template<> std::optional<component::ECC_Point> ExecutorBase<component::ECC_Point, operation::ECC_Point_Dbl>::callModule(std::shared_ptr<Module> module, operation::ECC_Point_Dbl& op) const {
872
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
873
874
0
    return module->OpECC_Point_Dbl(op);
875
0
}
876
877
/* Specialization for operation::DH_Derive */
878
1.27k
template<> void ExecutorBase<component::Bignum, operation::DH_Derive>::postprocess(std::shared_ptr<Module> module, operation::DH_Derive& op, const ExecutorBase<component::Bignum, operation::DH_Derive>::ResultPair& result) const {
879
1.27k
    (void)module;
880
1.27k
    (void)op;
881
1.27k
    (void)result;
882
1.27k
}
883
884
1.27k
template<> std::optional<component::Bignum> ExecutorBase<component::Bignum, operation::DH_Derive>::callModule(std::shared_ptr<Module> module, operation::DH_Derive& op) const {
885
1.27k
    if ( op.prime.GetSize() > config::kMaxBignumSize ) return std::nullopt;
886
1.26k
    if ( op.base.GetSize() > config::kMaxBignumSize ) return std::nullopt;
887
1.25k
    if ( op.pub.GetSize() > config::kMaxBignumSize ) return std::nullopt;
888
1.24k
    if ( op.priv.GetSize() > config::kMaxBignumSize ) return std::nullopt;
889
890
1.23k
    return module->OpDH_Derive(op);
891
1.24k
}
892
893
/* Specialization for operation::DH_GenerateKeyPair */
894
1.63k
template<> void ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>::postprocess(std::shared_ptr<Module> module, operation::DH_GenerateKeyPair& op, const ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>::ResultPair& result) const {
895
1.63k
    (void)result;
896
1.63k
    (void)op;
897
1.63k
    (void)module;
898
899
1.63k
    if ( result.second != std::nullopt && (PRNG() % 4) == 0 ) {
900
13
        const auto priv = result.second->first.ToTrimmedString();
901
13
        const auto pub = result.second->second.ToTrimmedString();
902
903
13
        Pool_DH_PrivateKey.Set(priv);
904
13
        Pool_DH_PublicKey.Set(pub);
905
13
    }
906
1.63k
}
907
908
1.63k
template<> std::optional<component::DH_KeyPair> ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>::callModule(std::shared_ptr<Module> module, operation::DH_GenerateKeyPair& op) const {
909
1.63k
    if ( op.prime.GetSize() > config::kMaxBignumSize ) return std::nullopt;
910
1.62k
    if ( op.base.GetSize() > config::kMaxBignumSize ) return std::nullopt;
911
912
1.60k
    return module->OpDH_GenerateKeyPair(op);
913
1.62k
}
914
915
/* Specialization for operation::BignumCalc */
916
29.6k
template<> void ExecutorBase<component::Bignum, operation::BignumCalc>::postprocess(std::shared_ptr<Module> module, operation::BignumCalc& op, const ExecutorBase<component::Bignum, operation::BignumCalc>::ResultPair& result) const {
917
29.6k
    (void)module;
918
29.6k
    (void)op;
919
920
29.6k
    if ( result.second != std::nullopt  ) {
921
10.8k
        const auto bignum = result.second->ToTrimmedString();
922
923
10.8k
        if ( bignum.size() <= config::kMaxBignumSize ) {
924
10.7k
            Pool_Bignum.Set(bignum);
925
10.7k
            if ( op.calcOp.Is(CF_CALCOP("Prime()")) ) {
926
303
                Pool_Bignum_Primes.Set(bignum);
927
303
            }
928
10.7k
        }
929
10.8k
        if ( op.calcOp.Is(CF_CALCOP("IsPrime(A)")) ) {
930
198
            if ( bignum == "1" ) {
931
73
                Pool_Bignum_Primes.Set(op.bn0.ToTrimmedString());
932
73
            }
933
198
        }
934
10.8k
    }
935
29.6k
}
936
937
29.6k
std::optional<component::Bignum> ExecutorBignumCalc::callModule(std::shared_ptr<Module> module, operation::BignumCalc& op) const {
938
29.6k
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
939
940
    /* Prevent timeouts */
941
29.6k
    if ( op.bn0.GetSize() > config::kMaxBignumSize ) return std::nullopt;
942
29.6k
    if ( op.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
943
29.6k
    if ( op.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
944
29.6k
    if ( op.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
945
946
29.6k
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
947
0
        return std::nullopt;
948
0
    }
949
950
29.6k
    switch ( op.calcOp.Get() ) {
951
158
        case    CF_CALCOP("SetBit(A,B)"):
952
            /* Don't allow setting very high bit positions (risk of memory exhaustion) */
953
158
            if ( op.bn1.GetSize() > 4 ) {
954
9
                return std::nullopt;
955
9
            }
956
149
            break;
957
149
        case    CF_CALCOP("Exp(A,B)"):
958
53
            if ( op.bn0.GetSize() > 5 || op.bn1.GetSize() > 2 ) {
959
34
                return std::nullopt;
960
34
            }
961
19
            break;
962
19
        case    CF_CALCOP("ModLShift(A,B,C)"):
963
18
            if ( op.bn1.GetSize() > 4 ) {
964
9
                return std::nullopt;
965
9
            }
966
9
            break;
967
180
        case    CF_CALCOP("Exp2(A)"):
968
180
            if ( op.bn0.GetSize() > 4 ) {
969
21
                return std::nullopt;
970
21
            }
971
159
            break;
972
29.6k
    }
973
974
29.5k
    return module->OpBignumCalc(op);
975
29.6k
}
976
977
/* Specialization for operation::BignumCalc_Fp2 */
978
0
template<> void ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>::postprocess(std::shared_ptr<Module> module, operation::BignumCalc_Fp2& op, const ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>::ResultPair& result) const {
979
0
    (void)module;
980
0
    (void)op;
981
982
0
    if ( result.second != std::nullopt  ) {
983
0
        const auto bignum_first = result.second->first.ToTrimmedString();
984
0
        const auto bignum_second = result.second->second.ToTrimmedString();
985
986
0
        if ( bignum_first.size() <= config::kMaxBignumSize ) {
987
0
            Pool_Bignum.Set(bignum_first);
988
0
        }
989
0
        if ( bignum_second.size() <= config::kMaxBignumSize ) {
990
0
            Pool_Bignum.Set(bignum_second);
991
0
        }
992
0
    }
993
0
}
994
995
0
std::optional<component::Fp2> ExecutorBignumCalc_Fp2::callModule(std::shared_ptr<Module> module, operation::BignumCalc_Fp2& op) const {
996
0
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
997
998
    /* Prevent timeouts */
999
0
    if ( op.bn0.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1000
0
    if ( op.bn0.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1001
0
    if ( op.bn1.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1002
0
    if ( op.bn1.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1003
0
    if ( op.bn2.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1004
0
    if ( op.bn2.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1005
0
    if ( op.bn3.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1006
0
    if ( op.bn3.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1007
1008
0
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
1009
0
        return std::nullopt;
1010
0
    }
1011
1012
0
    return module->OpBignumCalc_Fp2(op);
1013
0
}
1014
1015
/* Specialization for operation::BignumCalc_Fp12 */
1016
0
template<> void ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>::postprocess(std::shared_ptr<Module> module, operation::BignumCalc_Fp12& op, const ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>::ResultPair& result) const {
1017
0
    (void)module;
1018
0
    (void)op;
1019
1020
0
    if ( result.second != std::nullopt  ) {
1021
0
        Pool_Fp12.Set({
1022
0
                result.second->bn1.ToTrimmedString(),
1023
0
                result.second->bn2.ToTrimmedString(),
1024
0
                result.second->bn3.ToTrimmedString(),
1025
0
                result.second->bn4.ToTrimmedString(),
1026
0
                result.second->bn5.ToTrimmedString(),
1027
0
                result.second->bn6.ToTrimmedString(),
1028
0
                result.second->bn7.ToTrimmedString(),
1029
0
                result.second->bn8.ToTrimmedString(),
1030
0
                result.second->bn9.ToTrimmedString(),
1031
0
                result.second->bn10.ToTrimmedString(),
1032
0
                result.second->bn11.ToTrimmedString(),
1033
0
                result.second->bn12.ToTrimmedString()
1034
0
        });
1035
        /* TODO */
1036
#if 0
1037
        const auto bignum_first = result.second->first.ToTrimmedString();
1038
        const auto bignum_second = result.second->second.ToTrimmedString();
1039
1040
        if ( bignum_first.size() <= config::kMaxBignumSize ) {
1041
            Pool_Bignum.Set(bignum_first);
1042
        }
1043
        if ( bignum_second.size() <= config::kMaxBignumSize ) {
1044
            Pool_Bignum.Set(bignum_second);
1045
        }
1046
#endif
1047
0
    }
1048
0
}
1049
1050
0
std::optional<component::Fp12> ExecutorBignumCalc_Fp12::callModule(std::shared_ptr<Module> module, operation::BignumCalc_Fp12& op) const {
1051
0
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
1052
1053
    /* Prevent timeouts */
1054
0
    if ( op.bn0.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1055
0
    if ( op.bn0.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1056
0
    if ( op.bn0.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1057
0
    if ( op.bn0.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1058
0
    if ( op.bn0.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1059
0
    if ( op.bn0.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1060
0
    if ( op.bn0.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1061
0
    if ( op.bn0.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1062
0
    if ( op.bn0.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1063
0
    if ( op.bn0.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1064
0
    if ( op.bn0.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1065
0
    if ( op.bn0.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1066
1067
0
    if ( op.bn1.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1068
0
    if ( op.bn1.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1069
0
    if ( op.bn1.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1070
0
    if ( op.bn1.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1071
0
    if ( op.bn1.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1072
0
    if ( op.bn1.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1073
0
    if ( op.bn1.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1074
0
    if ( op.bn1.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1075
0
    if ( op.bn1.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1076
0
    if ( op.bn1.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1077
0
    if ( op.bn1.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1078
0
    if ( op.bn1.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1079
1080
0
    if ( op.bn2.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1081
0
    if ( op.bn2.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1082
0
    if ( op.bn2.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1083
0
    if ( op.bn2.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1084
0
    if ( op.bn2.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1085
0
    if ( op.bn2.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1086
0
    if ( op.bn2.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1087
0
    if ( op.bn2.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1088
0
    if ( op.bn2.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1089
0
    if ( op.bn2.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1090
0
    if ( op.bn2.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1091
0
    if ( op.bn2.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1092
1093
0
    if ( op.bn3.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1094
0
    if ( op.bn3.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1095
0
    if ( op.bn3.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1096
0
    if ( op.bn3.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1097
0
    if ( op.bn3.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1098
0
    if ( op.bn3.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1099
0
    if ( op.bn3.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1100
0
    if ( op.bn3.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1101
0
    if ( op.bn3.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1102
0
    if ( op.bn3.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1103
0
    if ( op.bn3.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1104
0
    if ( op.bn3.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1105
1106
0
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
1107
0
        return std::nullopt;
1108
0
    }
1109
1110
0
    return module->OpBignumCalc_Fp12(op);
1111
0
}
1112
1113
/* Specialization for operation::BLS_PrivateToPublic */
1114
0
template<> void ExecutorBase<component::BLS_PublicKey, operation::BLS_PrivateToPublic>::postprocess(std::shared_ptr<Module> module, operation::BLS_PrivateToPublic& op, const ExecutorBase<component::BLS_PublicKey, operation::BLS_PrivateToPublic>::ResultPair& result) const {
1115
0
    (void)module;
1116
1117
0
    if ( result.second != std::nullopt  ) {
1118
0
        const auto curveID = op.curveType.Get();
1119
0
        const auto g1_x = result.second->first.ToTrimmedString();
1120
0
        const auto g1_y = result.second->second.ToTrimmedString();
1121
1122
0
        G1AddToPool(curveID, g1_x, g1_y);
1123
1124
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1125
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1126
0
    }
1127
0
}
1128
1129
0
template<> std::optional<component::BLS_PublicKey> ExecutorBase<component::BLS_PublicKey, operation::BLS_PrivateToPublic>::callModule(std::shared_ptr<Module> module, operation::BLS_PrivateToPublic& op) const {
1130
0
    const size_t size = op.priv.ToTrimmedString().size();
1131
1132
0
    if ( size == 0 || size > 4096 ) {
1133
0
        return std::nullopt;
1134
0
    }
1135
1136
0
    return module->OpBLS_PrivateToPublic(op);
1137
0
}
1138
1139
/* Specialization for operation::BLS_PrivateToPublic_G2 */
1140
0
template<> void ExecutorBase<component::G2, operation::BLS_PrivateToPublic_G2>::postprocess(std::shared_ptr<Module> module, operation::BLS_PrivateToPublic_G2& op, const ExecutorBase<component::G2, operation::BLS_PrivateToPublic_G2>::ResultPair& result) const {
1141
0
    (void)module;
1142
0
    if ( result.second != std::nullopt  ) {
1143
0
        const auto curveID = op.curveType.Get();
1144
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1145
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1146
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1147
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1148
1149
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1150
1151
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1152
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1153
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1154
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1155
0
    }
1156
0
}
1157
1158
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_PrivateToPublic_G2>::callModule(std::shared_ptr<Module> module, operation::BLS_PrivateToPublic_G2& op) const {
1159
0
    const size_t size = op.priv.ToTrimmedString().size();
1160
1161
0
    if ( size == 0 || size > 4096 ) {
1162
0
        return std::nullopt;
1163
0
    }
1164
1165
0
    return module->OpBLS_PrivateToPublic_G2(op);
1166
0
}
1167
1168
/* Specialization for operation::BLS_Sign */
1169
0
template<> void ExecutorBase<component::BLS_Signature, operation::BLS_Sign>::postprocess(std::shared_ptr<Module> module, operation::BLS_Sign& op, const ExecutorBase<component::BLS_Signature, operation::BLS_Sign>::ResultPair& result) const {
1170
0
    (void)module;
1171
1172
0
    if ( result.second != std::nullopt  ) {
1173
0
        const auto curveID = op.curveType.Get();
1174
0
        const auto point_v = op.hashOrPoint ? op.point.first.first.ToTrimmedString() : "";
1175
0
        const auto point_w = op.hashOrPoint ? op.point.first.second.ToTrimmedString() : "";
1176
0
        const auto point_x = op.hashOrPoint ? op.point.second.first.ToTrimmedString() : "";
1177
0
        const auto point_y = op.hashOrPoint ? op.point.second.second.ToTrimmedString() : "";
1178
0
        const auto cleartext = op.hashOrPoint ? op.cleartext.ToHex() : "";
1179
0
        const auto dest = op.dest.ToHex();
1180
0
        const auto aug = op.aug.ToHex();
1181
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
1182
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
1183
0
        const auto sig_v = result.second->signature.first.first.ToTrimmedString();
1184
0
        const auto sig_w = result.second->signature.first.second.ToTrimmedString();
1185
0
        const auto sig_x = result.second->signature.second.first.ToTrimmedString();
1186
0
        const auto sig_y = result.second->signature.second.second.ToTrimmedString();
1187
1188
0
        G1AddToPool(curveID, pub_x, pub_y);
1189
0
        G2AddToPool(curveID, sig_v, sig_w, sig_x, sig_y);
1190
0
        Pool_CurveBLSSignature.Set({ curveID, op.hashOrPoint, point_v, point_w, point_x, point_y, cleartext, dest, aug, pub_x, pub_y, sig_v, sig_w, sig_x, sig_y});
1191
1192
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
1193
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
1194
0
        if ( sig_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_v); }
1195
0
        if ( sig_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_w); }
1196
0
        if ( sig_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_x); }
1197
0
        if ( sig_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_y); }
1198
0
    }
1199
0
}
1200
1201
0
template<> std::optional<component::BLS_Signature> ExecutorBase<component::BLS_Signature, operation::BLS_Sign>::callModule(std::shared_ptr<Module> module, operation::BLS_Sign& op) const {
1202
0
    const size_t size = op.priv.ToTrimmedString().size();
1203
1204
0
    if ( size == 0 || size > 4096 ) {
1205
0
        return std::nullopt;
1206
0
    }
1207
1208
0
    return module->OpBLS_Sign(op);
1209
0
}
1210
1211
/* Specialization for operation::BLS_Verify */
1212
0
template<> void ExecutorBase<bool, operation::BLS_Verify>::postprocess(std::shared_ptr<Module> module, operation::BLS_Verify& op, const ExecutorBase<bool, operation::BLS_Verify>::ResultPair& result) const {
1213
0
    (void)module;
1214
0
    (void)op;
1215
0
    (void)result;
1216
0
}
1217
1218
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_Verify>::callModule(std::shared_ptr<Module> module, operation::BLS_Verify& op) const {
1219
#if 0
1220
    const std::vector<size_t> sizes = {
1221
        op.pub.first.ToTrimmedString().size(),
1222
        op.pub.second.ToTrimmedString().size(),
1223
        op.signature.first.ToTrimmedString().size(),
1224
        op.signature.second.ToTrimmedString().size(),
1225
    };
1226
1227
    for (const auto& size : sizes) {
1228
        if ( size == 0 || size > 4096 ) {
1229
            return std::nullopt;
1230
        }
1231
    }
1232
#endif
1233
1234
0
    return module->OpBLS_Verify(op);
1235
0
}
1236
1237
/* Specialization for operation::BLS_BatchSign */
1238
0
template<> void ExecutorBase<component::BLS_BatchSignature, operation::BLS_BatchSign>::postprocess(std::shared_ptr<Module> module, operation::BLS_BatchSign& op, const ExecutorBase<component::BLS_BatchSignature, operation::BLS_BatchSign>::ResultPair& result) const {
1239
0
    (void)module;
1240
0
    (void)op;
1241
1242
0
    if ( result.second != std::nullopt  ) {
1243
0
        std::vector< std::pair<BLS_BatchSignature_::G1, BLS_BatchSignature_::G2> > msgpub;
1244
0
        for (const auto& mp : result.second->msgpub) {
1245
0
            msgpub.push_back(
1246
0
                    std::pair<BLS_BatchSignature_::G1, BLS_BatchSignature_::G2>{
1247
0
                        {
1248
0
                            mp.first.first.ToTrimmedString(),
1249
0
                            mp.first.second.ToTrimmedString()
1250
0
                        },
1251
0
                        {
1252
0
                            mp.second.first.first.ToTrimmedString(),
1253
0
                            mp.second.first.second.ToTrimmedString(),
1254
0
                            mp.second.second.first.ToTrimmedString(),
1255
0
                            mp.second.second.second.ToTrimmedString()
1256
0
                        }
1257
0
                    }
1258
0
            );
1259
0
            G1AddToPool(CF_ECC_CURVE("BLS12_381"), mp.first.first.ToTrimmedString(), mp.first.second.ToTrimmedString());
1260
0
            Pool_CurveBLSG2.Set({
1261
0
                    CF_ECC_CURVE("BLS12_381"),
1262
0
                    mp.second.first.first.ToTrimmedString(),
1263
0
                    mp.second.first.second.ToTrimmedString(),
1264
0
                    mp.second.second.first.ToTrimmedString(),
1265
0
                    mp.second.second.second.ToTrimmedString()
1266
0
            });
1267
0
        }
1268
0
        Pool_BLS_BatchSignature.Set({msgpub});
1269
0
    }
1270
0
}
1271
1272
0
template<> std::optional<component::BLS_BatchSignature> ExecutorBase<component::BLS_BatchSignature, operation::BLS_BatchSign>::callModule(std::shared_ptr<Module> module, operation::BLS_BatchSign& op) const {
1273
0
    return module->OpBLS_BatchSign(op);
1274
0
}
1275
1276
/* Specialization for operation::BLS_BatchVerify */
1277
0
template<> void ExecutorBase<bool, operation::BLS_BatchVerify>::postprocess(std::shared_ptr<Module> module, operation::BLS_BatchVerify& op, const ExecutorBase<bool, operation::BLS_BatchVerify>::ResultPair& result) const {
1278
0
    (void)module;
1279
0
    (void)op;
1280
0
    (void)result;
1281
0
}
1282
1283
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_BatchVerify>::callModule(std::shared_ptr<Module> module, operation::BLS_BatchVerify& op) const {
1284
0
    return module->OpBLS_BatchVerify(op);
1285
0
}
1286
1287
/* Specialization for operation::BLS_Aggregate_G1 */
1288
0
template<> void ExecutorBase<component::G1, operation::BLS_Aggregate_G1>::postprocess(std::shared_ptr<Module> module, operation::BLS_Aggregate_G1& op, const ExecutorBase<component::G1, operation::BLS_Aggregate_G1>::ResultPair& result) const {
1289
0
    (void)module;
1290
0
    (void)op;
1291
0
    (void)result;
1292
0
}
1293
1294
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_Aggregate_G1>::callModule(std::shared_ptr<Module> module, operation::BLS_Aggregate_G1& op) const {
1295
0
    return module->OpBLS_Aggregate_G1(op);
1296
0
}
1297
1298
/* Specialization for operation::BLS_Aggregate_G2 */
1299
0
template<> void ExecutorBase<component::G2, operation::BLS_Aggregate_G2>::postprocess(std::shared_ptr<Module> module, operation::BLS_Aggregate_G2& op, const ExecutorBase<component::G2, operation::BLS_Aggregate_G2>::ResultPair& result) const {
1300
0
    (void)module;
1301
0
    (void)op;
1302
0
    (void)result;
1303
0
}
1304
1305
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_Aggregate_G2>::callModule(std::shared_ptr<Module> module, operation::BLS_Aggregate_G2& op) const {
1306
0
    return module->OpBLS_Aggregate_G2(op);
1307
0
}
1308
1309
/* Specialization for operation::BLS_Pairing */
1310
0
template<> void ExecutorBase<component::Fp12, operation::BLS_Pairing>::postprocess(std::shared_ptr<Module> module, operation::BLS_Pairing& op, const ExecutorBase<component::Fp12, operation::BLS_Pairing>::ResultPair& result) const {
1311
0
    (void)module;
1312
0
    (void)op;
1313
1314
0
    if ( result.second != std::nullopt  ) {
1315
0
        Pool_Fp12.Set({
1316
0
                result.second->bn1.ToTrimmedString(),
1317
0
                result.second->bn2.ToTrimmedString(),
1318
0
                result.second->bn3.ToTrimmedString(),
1319
0
                result.second->bn4.ToTrimmedString(),
1320
0
                result.second->bn5.ToTrimmedString(),
1321
0
                result.second->bn6.ToTrimmedString(),
1322
0
                result.second->bn7.ToTrimmedString(),
1323
0
                result.second->bn8.ToTrimmedString(),
1324
0
                result.second->bn9.ToTrimmedString(),
1325
0
                result.second->bn10.ToTrimmedString(),
1326
0
                result.second->bn11.ToTrimmedString(),
1327
0
                result.second->bn12.ToTrimmedString()
1328
0
        });
1329
0
    }
1330
0
}
1331
1332
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_Pairing>::callModule(std::shared_ptr<Module> module, operation::BLS_Pairing& op) const {
1333
0
    return module->OpBLS_Pairing(op);
1334
0
}
1335
1336
/* Specialization for operation::BLS_MillerLoop */
1337
0
template<> void ExecutorBase<component::Fp12, operation::BLS_MillerLoop>::postprocess(std::shared_ptr<Module> module, operation::BLS_MillerLoop& op, const ExecutorBase<component::Fp12, operation::BLS_MillerLoop>::ResultPair& result) const {
1338
0
    (void)module;
1339
0
    (void)op;
1340
1341
0
    if ( result.second != std::nullopt  ) {
1342
0
        Pool_Fp12.Set({
1343
0
                result.second->bn1.ToTrimmedString(),
1344
0
                result.second->bn2.ToTrimmedString(),
1345
0
                result.second->bn3.ToTrimmedString(),
1346
0
                result.second->bn4.ToTrimmedString(),
1347
0
                result.second->bn5.ToTrimmedString(),
1348
0
                result.second->bn6.ToTrimmedString(),
1349
0
                result.second->bn7.ToTrimmedString(),
1350
0
                result.second->bn8.ToTrimmedString(),
1351
0
                result.second->bn9.ToTrimmedString(),
1352
0
                result.second->bn10.ToTrimmedString(),
1353
0
                result.second->bn11.ToTrimmedString(),
1354
0
                result.second->bn12.ToTrimmedString()
1355
0
        });
1356
0
    }
1357
0
}
1358
1359
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_MillerLoop>::callModule(std::shared_ptr<Module> module, operation::BLS_MillerLoop& op) const {
1360
0
    return module->OpBLS_MillerLoop(op);
1361
0
}
1362
1363
/* Specialization for operation::BLS_FinalExp */
1364
0
template<> void ExecutorBase<component::Fp12, operation::BLS_FinalExp>::postprocess(std::shared_ptr<Module> module, operation::BLS_FinalExp& op, const ExecutorBase<component::Fp12, operation::BLS_FinalExp>::ResultPair& result) const {
1365
0
    (void)module;
1366
0
    (void)op;
1367
1368
0
    if ( result.second != std::nullopt  ) {
1369
0
        Pool_Fp12.Set({
1370
0
                result.second->bn1.ToTrimmedString(),
1371
0
                result.second->bn2.ToTrimmedString(),
1372
0
                result.second->bn3.ToTrimmedString(),
1373
0
                result.second->bn4.ToTrimmedString(),
1374
0
                result.second->bn5.ToTrimmedString(),
1375
0
                result.second->bn6.ToTrimmedString(),
1376
0
                result.second->bn7.ToTrimmedString(),
1377
0
                result.second->bn8.ToTrimmedString(),
1378
0
                result.second->bn9.ToTrimmedString(),
1379
0
                result.second->bn10.ToTrimmedString(),
1380
0
                result.second->bn11.ToTrimmedString(),
1381
0
                result.second->bn12.ToTrimmedString()
1382
0
        });
1383
0
    }
1384
0
}
1385
1386
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_FinalExp>::callModule(std::shared_ptr<Module> module, operation::BLS_FinalExp& op) const {
1387
0
    return module->OpBLS_FinalExp(op);
1388
0
}
1389
1390
/* Specialization for operation::BLS_HashToG1 */
1391
0
template<> void ExecutorBase<component::G1, operation::BLS_HashToG1>::postprocess(std::shared_ptr<Module> module, operation::BLS_HashToG1& op, const ExecutorBase<component::G1, operation::BLS_HashToG1>::ResultPair& result) const {
1392
0
    (void)module;
1393
1394
0
    if ( result.second != std::nullopt  ) {
1395
0
        const auto curveID = op.curveType.Get();
1396
0
        const auto g1_x = result.second->first.ToTrimmedString();
1397
0
        const auto g1_y = result.second->second.ToTrimmedString();
1398
1399
0
        G1AddToPool(curveID, g1_x, g1_y);
1400
1401
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1402
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1403
0
    }
1404
0
}
1405
1406
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_HashToG1>::callModule(std::shared_ptr<Module> module, operation::BLS_HashToG1& op) const {
1407
0
    return module->OpBLS_HashToG1(op);
1408
0
}
1409
1410
/* Specialization for operation::BLS_MapToG1 */
1411
0
template<> void ExecutorBase<component::G1, operation::BLS_MapToG1>::postprocess(std::shared_ptr<Module> module, operation::BLS_MapToG1& op, const ExecutorBase<component::G1, operation::BLS_MapToG1>::ResultPair& result) const {
1412
0
    (void)module;
1413
1414
0
    if ( result.second != std::nullopt  ) {
1415
0
        const auto curveID = op.curveType.Get();
1416
0
        const auto g1_x = result.second->first.ToTrimmedString();
1417
0
        const auto g1_y = result.second->second.ToTrimmedString();
1418
1419
0
        G1AddToPool(curveID, g1_x, g1_y);
1420
1421
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1422
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1423
0
    }
1424
0
}
1425
1426
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_MapToG1>::callModule(std::shared_ptr<Module> module, operation::BLS_MapToG1& op) const {
1427
0
    return module->OpBLS_MapToG1(op);
1428
0
}
1429
1430
/* Specialization for operation::BLS_MapToG2 */
1431
0
template<> void ExecutorBase<component::G2, operation::BLS_MapToG2>::postprocess(std::shared_ptr<Module> module, operation::BLS_MapToG2& op, const ExecutorBase<component::G2, operation::BLS_MapToG2>::ResultPair& result) const {
1432
0
    (void)module;
1433
1434
0
    if ( result.second != std::nullopt  ) {
1435
0
        const auto curveID = op.curveType.Get();
1436
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1437
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1438
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1439
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1440
1441
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1442
1443
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1444
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1445
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1446
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1447
0
    }
1448
0
}
1449
1450
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_MapToG2>::callModule(std::shared_ptr<Module> module, operation::BLS_MapToG2& op) const {
1451
0
    return module->OpBLS_MapToG2(op);
1452
0
}
1453
1454
/* Specialization for operation::BLS_IsG1OnCurve */
1455
0
template<> void ExecutorBase<bool, operation::BLS_IsG1OnCurve>::postprocess(std::shared_ptr<Module> module, operation::BLS_IsG1OnCurve& op, const ExecutorBase<bool, operation::BLS_IsG1OnCurve>::ResultPair& result) const {
1456
0
    (void)module;
1457
0
    (void)op;
1458
0
    (void)result;
1459
0
}
1460
1461
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_IsG1OnCurve>::callModule(std::shared_ptr<Module> module, operation::BLS_IsG1OnCurve& op) const {
1462
0
    if ( op.g1.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1463
0
    if ( op.g1.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1464
1465
0
    return module->OpBLS_IsG1OnCurve(op);
1466
0
}
1467
1468
/* Specialization for operation::BLS_IsG2OnCurve */
1469
0
template<> void ExecutorBase<bool, operation::BLS_IsG2OnCurve>::postprocess(std::shared_ptr<Module> module, operation::BLS_IsG2OnCurve& op, const ExecutorBase<bool, operation::BLS_IsG2OnCurve>::ResultPair& result) const {
1470
0
    (void)module;
1471
0
    (void)op;
1472
0
    (void)result;
1473
0
}
1474
1475
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_IsG2OnCurve>::callModule(std::shared_ptr<Module> module, operation::BLS_IsG2OnCurve& op) const {
1476
0
    if ( op.g2.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1477
0
    if ( op.g2.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1478
0
    if ( op.g2.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1479
0
    if ( op.g2.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1480
1481
0
    return module->OpBLS_IsG2OnCurve(op);
1482
0
}
1483
1484
/* Specialization for operation::BLS_GenerateKeyPair */
1485
0
template<> void ExecutorBase<component::BLS_KeyPair, operation::BLS_GenerateKeyPair>::postprocess(std::shared_ptr<Module> module, operation::BLS_GenerateKeyPair& op, const ExecutorBase<component::BLS_KeyPair, operation::BLS_GenerateKeyPair>::ResultPair& result) const {
1486
0
    (void)module;
1487
1488
0
    if ( result.second != std::nullopt  ) {
1489
0
        const auto curveID = op.curveType.Get();
1490
0
        const auto priv = result.second->priv.ToTrimmedString();
1491
0
        const auto g1_x = result.second->pub.first.ToTrimmedString();
1492
0
        const auto g1_y = result.second->pub.second.ToTrimmedString();
1493
1494
0
        G1AddToPool(curveID, g1_x, g1_y);
1495
1496
0
        if ( priv.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(priv); }
1497
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1498
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1499
0
    }
1500
0
}
1501
1502
0
template<> std::optional<component::BLS_KeyPair> ExecutorBase<component::BLS_KeyPair, operation::BLS_GenerateKeyPair>::callModule(std::shared_ptr<Module> module, operation::BLS_GenerateKeyPair& op) const {
1503
0
    return module->OpBLS_GenerateKeyPair(op);
1504
0
}
1505
1506
/* Specialization for operation::BLS_Decompress_G1 */
1507
0
template<> void ExecutorBase<component::G1, operation::BLS_Decompress_G1>::postprocess(std::shared_ptr<Module> module, operation::BLS_Decompress_G1& op, const ExecutorBase<component::G1, operation::BLS_Decompress_G1>::ResultPair& result) const {
1508
0
    (void)module;
1509
1510
0
    if ( result.second != std::nullopt  ) {
1511
0
        const auto curveID = op.curveType.Get();
1512
0
        const auto g1_x = result.second->first.ToTrimmedString();
1513
0
        const auto g1_y = result.second->second.ToTrimmedString();
1514
1515
0
        G1AddToPool(curveID, g1_x, g1_y);
1516
1517
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1518
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1519
0
    }
1520
0
}
1521
1522
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_Decompress_G1>::callModule(std::shared_ptr<Module> module, operation::BLS_Decompress_G1& op) const {
1523
0
    return module->OpBLS_Decompress_G1(op);
1524
0
}
1525
1526
/* Specialization for operation::BLS_Compress_G1 */
1527
0
template<> void ExecutorBase<component::Bignum, operation::BLS_Compress_G1>::postprocess(std::shared_ptr<Module> module, operation::BLS_Compress_G1& op, const ExecutorBase<component::Bignum, operation::BLS_Compress_G1>::ResultPair& result) const {
1528
0
    (void)module;
1529
1530
0
    if ( result.second != std::nullopt  ) {
1531
0
        const auto compressed = result.second->ToTrimmedString();
1532
1533
0
        if ( compressed.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(compressed); }
1534
0
    }
1535
0
}
1536
1537
0
template<> std::optional<component::Bignum> ExecutorBase<component::Bignum, operation::BLS_Compress_G1>::callModule(std::shared_ptr<Module> module, operation::BLS_Compress_G1& op) const {
1538
0
    return module->OpBLS_Compress_G1(op);
1539
0
}
1540
1541
/* Specialization for operation::BLS_Decompress_G2 */
1542
0
template<> void ExecutorBase<component::G2, operation::BLS_Decompress_G2>::postprocess(std::shared_ptr<Module> module, operation::BLS_Decompress_G2& op, const ExecutorBase<component::G2, operation::BLS_Decompress_G2>::ResultPair& result) const {
1543
0
    (void)module;
1544
1545
0
    if ( result.second != std::nullopt  ) {
1546
0
        const auto curveID = op.curveType.Get();
1547
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1548
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1549
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1550
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1551
1552
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1553
1554
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1555
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1556
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1557
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1558
0
    }
1559
0
}
1560
1561
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_Decompress_G2>::callModule(std::shared_ptr<Module> module, operation::BLS_Decompress_G2& op) const {
1562
0
    return module->OpBLS_Decompress_G2(op);
1563
0
}
1564
1565
/* Specialization for operation::BLS_Compress_G2 */
1566
0
template<> void ExecutorBase<component::G1, operation::BLS_Compress_G2>::postprocess(std::shared_ptr<Module> module, operation::BLS_Compress_G2& op, const ExecutorBase<component::G1, operation::BLS_Compress_G2>::ResultPair& result) const {
1567
0
    (void)module;
1568
1569
0
    if ( result.second != std::nullopt  ) {
1570
0
        const auto curveID = op.curveType.Get();
1571
0
        const auto g1_x = result.second->first.ToTrimmedString();
1572
0
        const auto g1_y = result.second->second.ToTrimmedString();
1573
1574
0
        G1AddToPool(curveID, g1_x, g1_y);
1575
1576
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1577
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1578
0
    }
1579
0
}
1580
1581
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_Compress_G2>::callModule(std::shared_ptr<Module> module, operation::BLS_Compress_G2& op) const {
1582
0
    return module->OpBLS_Compress_G2(op);
1583
0
}
1584
1585
/* Specialization for operation::BLS_G1_Add */
1586
0
template<> void ExecutorBase<component::G1, operation::BLS_G1_Add>::postprocess(std::shared_ptr<Module> module, operation::BLS_G1_Add& op, const ExecutorBase<component::G1, operation::BLS_G1_Add>::ResultPair& result) const {
1587
0
    (void)module;
1588
1589
0
    if ( result.second != std::nullopt  ) {
1590
0
        const auto curveID = op.curveType.Get();
1591
0
        const auto g1_x = result.second->first.ToTrimmedString();
1592
0
        const auto g1_y = result.second->second.ToTrimmedString();
1593
1594
0
        G1AddToPool(curveID, g1_x, g1_y);
1595
1596
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1597
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1598
0
    }
1599
0
}
1600
1601
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_G1_Add>::callModule(std::shared_ptr<Module> module, operation::BLS_G1_Add& op) const {
1602
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1603
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1604
0
    if ( op.b.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1605
0
    if ( op.b.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1606
1607
0
    return module->OpBLS_G1_Add(op);
1608
0
}
1609
1610
/* Specialization for operation::BLS_G1_Mul */
1611
0
template<> void ExecutorBase<component::G1, operation::BLS_G1_Mul>::postprocess(std::shared_ptr<Module> module, operation::BLS_G1_Mul& op, const ExecutorBase<component::G1, operation::BLS_G1_Mul>::ResultPair& result) const {
1612
0
    (void)module;
1613
1614
0
    if ( result.second != std::nullopt  ) {
1615
0
        const auto curveID = op.curveType.Get();
1616
0
        const auto g1_x = result.second->first.ToTrimmedString();
1617
0
        const auto g1_y = result.second->second.ToTrimmedString();
1618
1619
0
        G1AddToPool(curveID, g1_x, g1_y);
1620
1621
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1622
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1623
0
    }
1624
0
}
1625
1626
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_G1_Mul>::callModule(std::shared_ptr<Module> module, operation::BLS_G1_Mul& op) const {
1627
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1628
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1629
0
    if ( op.b.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1630
1631
0
    return module->OpBLS_G1_Mul(op);
1632
0
}
1633
1634
/* Specialization for operation::BLS_G1_IsEq */
1635
0
template<> void ExecutorBase<bool, operation::BLS_G1_IsEq>::postprocess(std::shared_ptr<Module> module, operation::BLS_G1_IsEq& op, const ExecutorBase<bool, operation::BLS_G1_IsEq>::ResultPair& result) const {
1636
0
    (void)module;
1637
0
    (void)op;
1638
0
    (void)result;
1639
0
}
1640
1641
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_G1_IsEq>::callModule(std::shared_ptr<Module> module, operation::BLS_G1_IsEq& op) const {
1642
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1643
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1644
0
    if ( op.b.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1645
0
    if ( op.b.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1646
1647
0
    return module->OpBLS_G1_IsEq(op);
1648
0
}
1649
1650
/* Specialization for operation::BLS_G1_Neg */
1651
0
template<> void ExecutorBase<component::G1, operation::BLS_G1_Neg>::postprocess(std::shared_ptr<Module> module, operation::BLS_G1_Neg& op, const ExecutorBase<component::G1, operation::BLS_G1_Neg>::ResultPair& result) const {
1652
0
    (void)module;
1653
1654
0
    if ( result.second != std::nullopt  ) {
1655
0
        const auto curveID = op.curveType.Get();
1656
0
        const auto g1_x = result.second->first.ToTrimmedString();
1657
0
        const auto g1_y = result.second->second.ToTrimmedString();
1658
1659
0
        G1AddToPool(curveID, g1_x, g1_y);
1660
1661
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1662
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1663
0
    }
1664
0
}
1665
1666
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_G1_Neg>::callModule(std::shared_ptr<Module> module, operation::BLS_G1_Neg& op) const {
1667
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1668
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1669
1670
0
    return module->OpBLS_G1_Neg(op);
1671
0
}
1672
1673
/* Specialization for operation::BLS_G2_Add */
1674
0
template<> void ExecutorBase<component::G2, operation::BLS_G2_Add>::postprocess(std::shared_ptr<Module> module, operation::BLS_G2_Add& op, const ExecutorBase<component::G2, operation::BLS_G2_Add>::ResultPair& result) const {
1675
0
    (void)module;
1676
1677
0
    if ( result.second != std::nullopt  ) {
1678
0
        const auto curveID = op.curveType.Get();
1679
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1680
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1681
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1682
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1683
1684
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1685
1686
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1687
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1688
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1689
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1690
0
    }
1691
0
}
1692
1693
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_G2_Add>::callModule(std::shared_ptr<Module> module, operation::BLS_G2_Add& op) const {
1694
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1695
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1696
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1697
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1698
0
    if ( op.b.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1699
0
    if ( op.b.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1700
0
    if ( op.b.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1701
0
    if ( op.b.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1702
1703
0
    return module->OpBLS_G2_Add(op);
1704
0
}
1705
1706
/* Specialization for operation::BLS_G2_Mul */
1707
0
template<> void ExecutorBase<component::G2, operation::BLS_G2_Mul>::postprocess(std::shared_ptr<Module> module, operation::BLS_G2_Mul& op, const ExecutorBase<component::G2, operation::BLS_G2_Mul>::ResultPair& result) const {
1708
0
    (void)module;
1709
1710
0
    if ( result.second != std::nullopt  ) {
1711
0
        const auto curveID = op.curveType.Get();
1712
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1713
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1714
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1715
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1716
1717
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1718
1719
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1720
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1721
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1722
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1723
0
    }
1724
0
}
1725
1726
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_G2_Mul>::callModule(std::shared_ptr<Module> module, operation::BLS_G2_Mul& op) const {
1727
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1728
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1729
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1730
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1731
0
    if ( op.b.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1732
1733
0
    return module->OpBLS_G2_Mul(op);
1734
0
}
1735
1736
/* Specialization for operation::BLS_G2_IsEq */
1737
0
template<> void ExecutorBase<bool, operation::BLS_G2_IsEq>::postprocess(std::shared_ptr<Module> module, operation::BLS_G2_IsEq& op, const ExecutorBase<bool, operation::BLS_G2_IsEq>::ResultPair& result) const {
1738
0
    (void)module;
1739
0
    (void)op;
1740
0
    (void)result;
1741
0
}
1742
1743
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_G2_IsEq>::callModule(std::shared_ptr<Module> module, operation::BLS_G2_IsEq& op) const {
1744
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1745
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1746
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1747
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1748
0
    if ( op.b.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1749
0
    if ( op.b.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1750
0
    if ( op.b.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1751
0
    if ( op.b.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1752
1753
0
    return module->OpBLS_G2_IsEq(op);
1754
0
}
1755
1756
/* Specialization for operation::BLS_G2_Neg */
1757
0
template<> void ExecutorBase<component::G2, operation::BLS_G2_Neg>::postprocess(std::shared_ptr<Module> module, operation::BLS_G2_Neg& op, const ExecutorBase<component::G2, operation::BLS_G2_Neg>::ResultPair& result) const {
1758
0
    (void)module;
1759
1760
0
    if ( result.second != std::nullopt  ) {
1761
0
        const auto curveID = op.curveType.Get();
1762
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1763
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1764
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1765
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1766
1767
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1768
1769
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1770
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1771
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1772
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1773
0
    }
1774
0
}
1775
1776
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_G2_Neg>::callModule(std::shared_ptr<Module> module, operation::BLS_G2_Neg& op) const {
1777
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1778
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1779
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1780
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1781
1782
0
    return module->OpBLS_G2_Neg(op);
1783
0
}
1784
1785
/* Specialization for operation::Misc */
1786
0
template<> void ExecutorBase<Buffer, operation::Misc>::postprocess(std::shared_ptr<Module> module, operation::Misc& op, const ExecutorBase<Buffer, operation::Misc>::ResultPair& result) const {
1787
0
    (void)module;
1788
0
    (void)op;
1789
0
    (void)result;
1790
0
}
1791
1792
0
template<> std::optional<Buffer> ExecutorBase<Buffer, operation::Misc>::callModule(std::shared_ptr<Module> module, operation::Misc& op) const {
1793
0
    return module->OpMisc(op);
1794
0
}
1795
1796
/* Specialization for operation::BLS_HashToG2 */
1797
0
template<> void ExecutorBase<component::G2, operation::BLS_HashToG2>::postprocess(std::shared_ptr<Module> module, operation::BLS_HashToG2& op, const ExecutorBase<component::G2, operation::BLS_HashToG2>::ResultPair& result) const {
1798
0
    (void)module;
1799
1800
0
    if ( result.second != std::nullopt  ) {
1801
0
        const auto curveID = op.curveType.Get();
1802
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1803
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1804
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1805
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1806
1807
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1808
1809
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1810
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1811
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1812
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1813
0
    }
1814
0
}
1815
1816
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_HashToG2>::callModule(std::shared_ptr<Module> module, operation::BLS_HashToG2& op) const {
1817
0
    return module->OpBLS_HashToG2(op);
1818
0
}
1819
1820
ExecutorBignumCalc::ExecutorBignumCalc(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1821
    ExecutorBase<component::Bignum, operation::BignumCalc>::ExecutorBase(operationID, modules, options)
1822
18
{ }
1823
17
void ExecutorBignumCalc::SetModulo(const std::string& modulo) {
1824
17
    this->modulo = component::Bignum(modulo);
1825
17
}
1826
1827
ExecutorBignumCalc_Mod_BLS12_381_R::ExecutorBignumCalc_Mod_BLS12_381_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1828
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1829
1
    CF_NORET(SetModulo("52435875175126190479447740508185965837690552500527637822603658699938581184513"));
1830
1
}
1831
1832
ExecutorBignumCalc_Mod_BLS12_381_P::ExecutorBignumCalc_Mod_BLS12_381_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1833
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1834
1
    CF_NORET(SetModulo("4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"));
1835
1
}
1836
1837
ExecutorBignumCalc_Mod_BN128_R::ExecutorBignumCalc_Mod_BN128_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1838
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1839
1
    CF_NORET(SetModulo("21888242871839275222246405745257275088548364400416034343698204186575808495617"));
1840
1
}
1841
1842
ExecutorBignumCalc_Mod_BN128_P::ExecutorBignumCalc_Mod_BN128_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1843
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1844
1
    CF_NORET(SetModulo("21888242871839275222246405745257275088696311157297823662689037894645226208583"));
1845
1
}
1846
1847
ExecutorBignumCalc_Mod_ED25519::ExecutorBignumCalc_Mod_ED25519(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1848
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1849
1
    CF_NORET(SetModulo("57896044618658097711785492504343953926634992332820282019728792003956564819949"));
1850
1
}
1851
1852
ExecutorBignumCalc_Mod_Edwards_R::ExecutorBignumCalc_Mod_Edwards_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1853
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1854
1
    CF_NORET(SetModulo("1552511030102430251236801561344621993261920897571225601"));
1855
1
}
1856
1857
ExecutorBignumCalc_Mod_Edwards_P::ExecutorBignumCalc_Mod_Edwards_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1858
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1859
1
    CF_NORET(SetModulo("6210044120409721004947206240885978274523751269793792001"));
1860
1
}
1861
1862
ExecutorBignumCalc_Mod_MNT4_R::ExecutorBignumCalc_Mod_MNT4_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1863
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1864
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963137"));
1865
1
}
1866
1867
ExecutorBignumCalc_Mod_MNT4_P::ExecutorBignumCalc_Mod_MNT4_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1868
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1869
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081"));
1870
1
}
1871
1872
ExecutorBignumCalc_Mod_MNT6_R::ExecutorBignumCalc_Mod_MNT6_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1873
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1874
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081"));
1875
1
}
1876
1877
ExecutorBignumCalc_Mod_MNT6_P::ExecutorBignumCalc_Mod_MNT6_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1878
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1879
1
    CF_NORET(SetModulo("237961143084630662876674624826524225772562439621347362697777564288105131408977900241879040"));
1880
1
}
1881
1882
ExecutorBignumCalc_Mod_2Exp64::ExecutorBignumCalc_Mod_2Exp64(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1883
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1884
1
    CF_NORET(SetModulo("18446744073709551616"));
1885
1
}
1886
1887
ExecutorBignumCalc_Mod_2Exp128::ExecutorBignumCalc_Mod_2Exp128(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1888
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1889
1
    CF_NORET(SetModulo("340282366920938463463374607431768211456"));
1890
1
}
1891
1892
ExecutorBignumCalc_Mod_2Exp256::ExecutorBignumCalc_Mod_2Exp256(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1893
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1894
1
    CF_NORET(SetModulo("115792089237316195423570985008687907853269984665640564039457584007913129639936"));
1895
1
}
1896
1897
ExecutorBignumCalc_Mod_2Exp512::ExecutorBignumCalc_Mod_2Exp512(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1898
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1899
1
    CF_NORET(SetModulo("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"));
1900
1
}
1901
1902
ExecutorBignumCalc_Mod_SECP256K1::ExecutorBignumCalc_Mod_SECP256K1(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1903
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1904
1
    CF_NORET(SetModulo("115792089237316195423570985008687907852837564279074904382605163141518161494337"));
1905
1
}
1906
1907
ExecutorBignumCalc_Mod_SECP256K1_P::ExecutorBignumCalc_Mod_SECP256K1_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1908
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
1909
1
    CF_NORET(SetModulo("115792089237316195423570985008687907853269984665640564039457584007908834671663"));
1910
1
}
1911
1912
ExecutorBignumCalc_Fp2::ExecutorBignumCalc_Fp2(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1913
    ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>::ExecutorBase(operationID, modules, options)
1914
1
{ }
1915
0
void ExecutorBignumCalc_Fp2::SetModulo(const std::string& modulo) {
1916
0
    this->modulo = component::Bignum(modulo);
1917
0
}
1918
1919
ExecutorBignumCalc_Fp12::ExecutorBignumCalc_Fp12(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1920
    ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>::ExecutorBase(operationID, modules, options)
1921
1
{ }
1922
0
void ExecutorBignumCalc_Fp12::SetModulo(const std::string& modulo) {
1923
0
    this->modulo = component::Bignum(modulo);
1924
0
}
1925
1926
template <class ResultType, class OperationType>
1927
ExecutorBase<ResultType, OperationType>::ExecutorBase(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
1928
    operationID(operationID),
1929
    modules(modules),
1930
    options(options)
1931
90
{
1932
90
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
18
{
1932
18
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::ExecutorBase(unsigned long, std::__1::map<unsigned long, std::__1::shared_ptr<cryptofuzz::Module>, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, std::__1::shared_ptr<cryptofuzz::Module> > > > const&, cryptofuzz::Options const&)
Line
Count
Source
1931
1
{
1932
1
}
1933
1934
/* Specialization for operation::SR25519_Verify */
1935
0
template<> void ExecutorBase<bool, operation::SR25519_Verify>::postprocess(std::shared_ptr<Module> module, operation::SR25519_Verify& op, const ExecutorBase<bool, operation::SR25519_Verify>::ResultPair& result) const {
1936
0
    (void)module;
1937
0
    (void)op;
1938
0
    (void)result;
1939
0
}
1940
1941
0
template<> std::optional<bool> ExecutorBase<bool, operation::SR25519_Verify>::callModule(std::shared_ptr<Module> module, operation::SR25519_Verify& op) const {
1942
0
    return module->OpSR25519_Verify(op);
1943
0
}
1944
1945
template <class ResultType, class OperationType>
1946
90
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
90
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::~ExecutorBase()
Line
Count
Source
1946
18
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
18
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::~ExecutorBase()
Line
Count
Source
1946
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
1947
1
}
1948
1949
/* Filter away the values in the set that are std::nullopt */
1950
template <class ResultType, class OperationType>
1951
20.7k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
20.7k
    ResultSet ret;
1953
1954
47.3k
    for (const auto& result : results) {
1955
47.3k
        if ( result.second == std::nullopt ) {
1956
30.6k
            continue;
1957
30.6k
        }
1958
1959
16.7k
        ret.push_back(result);
1960
16.7k
    }
1961
1962
20.7k
    return ret;
1963
20.7k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Line
Count
Source
1951
1.18k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
1.18k
    ResultSet ret;
1953
1954
2.67k
    for (const auto& result : results) {
1955
2.67k
        if ( result.second == std::nullopt ) {
1956
1.50k
            continue;
1957
1.50k
        }
1958
1959
1.16k
        ret.push_back(result);
1960
1.16k
    }
1961
1962
1.18k
    return ret;
1963
1.18k
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Line
Count
Source
1951
978
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
978
    ResultSet ret;
1953
1954
2.42k
    for (const auto& result : results) {
1955
2.42k
        if ( result.second == std::nullopt ) {
1956
1.15k
            continue;
1957
1.15k
        }
1958
1959
1.26k
        ret.push_back(result);
1960
1.26k
    }
1961
1962
978
    return ret;
1963
978
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECC_KeyPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECC_KeyPair> > > > const&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&) const
Line
Count
Source
1951
1.52k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
1.52k
    ResultSet ret;
1953
1954
4.33k
    for (const auto& result : results) {
1955
4.33k
        if ( result.second == std::nullopt ) {
1956
2.19k
            continue;
1957
2.19k
        }
1958
1959
2.14k
        ret.push_back(result);
1960
2.14k
    }
1961
1962
1.52k
    return ret;
1963
1.52k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Line
Count
Source
1951
757
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
757
    ResultSet ret;
1953
1954
1.97k
    for (const auto& result : results) {
1955
1.97k
        if ( result.second == std::nullopt ) {
1956
1.23k
            continue;
1957
1.23k
        }
1958
1959
739
        ret.push_back(result);
1960
739
    }
1961
1962
757
    return ret;
1963
757
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Line
Count
Source
1951
103
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
103
    ResultSet ret;
1953
1954
336
    for (const auto& result : results) {
1955
336
        if ( result.second == std::nullopt ) {
1956
293
            continue;
1957
293
        }
1958
1959
43
        ret.push_back(result);
1960
43
    }
1961
1962
103
    return ret;
1963
103
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> > > > const&) const
Line
Count
Source
1951
182
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
182
    ResultSet ret;
1953
1954
657
    for (const auto& result : results) {
1955
657
        if ( result.second == std::nullopt ) {
1956
602
            continue;
1957
602
        }
1958
1959
55
        ret.push_back(result);
1960
55
    }
1961
1962
182
    return ret;
1963
182
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Line
Count
Source
1951
132
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
132
    ResultSet ret;
1953
1954
433
    for (const auto& result : results) {
1955
433
        if ( result.second == std::nullopt ) {
1956
431
            continue;
1957
431
        }
1958
1959
2
        ret.push_back(result);
1960
2
    }
1961
1962
132
    return ret;
1963
132
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Line
Count
Source
1951
783
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
783
    ResultSet ret;
1953
1954
1.83k
    for (const auto& result : results) {
1955
1.83k
        if ( result.second == std::nullopt ) {
1956
1.77k
            continue;
1957
1.77k
        }
1958
1959
60
        ret.push_back(result);
1960
60
    }
1961
1962
783
    return ret;
1963
783
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Line
Count
Source
1951
711
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
711
    ResultSet ret;
1953
1954
1.74k
    for (const auto& result : results) {
1955
1.74k
        if ( result.second == std::nullopt ) {
1956
1.55k
            continue;
1957
1.55k
        }
1958
1959
190
        ret.push_back(result);
1960
190
    }
1961
1962
711
    return ret;
1963
711
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&) const
Line
Count
Source
1951
484
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
484
    ResultSet ret;
1953
1954
1.27k
    for (const auto& result : results) {
1955
1.27k
        if ( result.second == std::nullopt ) {
1956
999
            continue;
1957
999
        }
1958
1959
276
        ret.push_back(result);
1960
276
    }
1961
1962
484
    return ret;
1963
484
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&) const
Line
Count
Source
1951
13.8k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
1952
13.8k
    ResultSet ret;
1953
1954
29.6k
    for (const auto& result : results) {
1955
29.6k
        if ( result.second == std::nullopt ) {
1956
18.8k
            continue;
1957
18.8k
        }
1958
1959
10.8k
        ret.push_back(result);
1960
10.8k
    }
1961
1962
13.8k
    return ret;
1963
13.8k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_Signature> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_BatchSignature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_BatchSignature> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_KeyPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_KeyPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&) const
1964
1965
/* Do not compare ECC_GenerateKeyPair results, because the result can be produced indeterministically */
1966
template <>
1967
1.34k
void ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::ECC_GenerateKeyPair> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
1968
1.34k
    (void)operations;
1969
1.34k
    (void)results;
1970
1.34k
    (void)data;
1971
1.34k
    (void)size;
1972
1.34k
}
1973
1974
template <class ResultType, class OperationType>
1975
1.01k
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
1.01k
    (void)operation;
1977
1978
1.01k
    return false;
1979
1.01k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::dontCompare(cryptofuzz::operation::Digest const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::dontCompare(cryptofuzz::operation::UMAC const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::dontCompare(cryptofuzz::operation::KDF_SCRYPT const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::dontCompare(cryptofuzz::operation::KDF_HKDF const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::dontCompare(cryptofuzz::operation::KDF_TLS1_PRF const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::dontCompare(cryptofuzz::operation::KDF_PBKDF const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::dontCompare(cryptofuzz::operation::KDF_PBKDF1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::dontCompare(cryptofuzz::operation::KDF_PBKDF2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::dontCompare(cryptofuzz::operation::KDF_ARGON2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::dontCompare(cryptofuzz::operation::KDF_SSH const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::dontCompare(cryptofuzz::operation::KDF_X963 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::dontCompare(cryptofuzz::operation::KDF_BCRYPT const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::dontCompare(cryptofuzz::operation::KDF_SP_800_108 const&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::dontCompare(cryptofuzz::operation::ECC_PrivateToPublic const&) const
Line
Count
Source
1975
368
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
368
    (void)operation;
1977
1978
368
    return false;
1979
368
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::dontCompare(cryptofuzz::operation::ECC_ValidatePubkey const&) const
Line
Count
Source
1975
409
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
409
    (void)operation;
1977
1978
409
    return false;
1979
409
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::dontCompare(cryptofuzz::operation::ECC_GenerateKeyPair const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::dontCompare(cryptofuzz::operation::Schnorr_Sign const&) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::dontCompare(cryptofuzz::operation::ECDSA_Verify const&) const
Line
Count
Source
1975
124
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
124
    (void)operation;
1977
1978
124
    return false;
1979
124
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::dontCompare(cryptofuzz::operation::ECGDSA_Verify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::dontCompare(cryptofuzz::operation::ECRDSA_Verify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::dontCompare(cryptofuzz::operation::Schnorr_Verify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::dontCompare(cryptofuzz::operation::ECDSA_Recover const&) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::dontCompare(cryptofuzz::operation::ECDH_Derive const&) const
Line
Count
Source
1975
12
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
12
    (void)operation;
1977
1978
12
    return false;
1979
12
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::dontCompare(cryptofuzz::operation::ECIES_Encrypt const&) const
Line
Count
Source
1975
11
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
11
    (void)operation;
1977
1978
11
    return false;
1979
11
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::dontCompare(cryptofuzz::operation::ECIES_Decrypt const&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::dontCompare(cryptofuzz::operation::ECC_Point_Add const&) const
Line
Count
Source
1975
16
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
16
    (void)operation;
1977
1978
16
    return false;
1979
16
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::dontCompare(cryptofuzz::operation::ECC_Point_Mul const&) const
Line
Count
Source
1975
30
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
30
    (void)operation;
1977
1978
30
    return false;
1979
30
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::dontCompare(cryptofuzz::operation::ECC_Point_Neg const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::dontCompare(cryptofuzz::operation::ECC_Point_Dbl const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::dontCompare(cryptofuzz::operation::DH_GenerateKeyPair const&) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::dontCompare(cryptofuzz::operation::DH_Derive const&) const
Line
Count
Source
1975
48
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
1976
48
    (void)operation;
1977
1978
48
    return false;
1979
48
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::dontCompare(cryptofuzz::operation::BignumCalc_Fp2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::dontCompare(cryptofuzz::operation::BignumCalc_Fp12 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::dontCompare(cryptofuzz::operation::BLS_PrivateToPublic const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::dontCompare(cryptofuzz::operation::BLS_PrivateToPublic_G2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::dontCompare(cryptofuzz::operation::BLS_Sign const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::dontCompare(cryptofuzz::operation::BLS_Verify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::dontCompare(cryptofuzz::operation::BLS_BatchSign const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::dontCompare(cryptofuzz::operation::BLS_BatchVerify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::dontCompare(cryptofuzz::operation::BLS_Aggregate_G1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::dontCompare(cryptofuzz::operation::BLS_Aggregate_G2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::dontCompare(cryptofuzz::operation::BLS_Pairing const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::dontCompare(cryptofuzz::operation::BLS_MillerLoop const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::dontCompare(cryptofuzz::operation::BLS_FinalExp const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::dontCompare(cryptofuzz::operation::BLS_HashToG1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::dontCompare(cryptofuzz::operation::BLS_HashToG2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::dontCompare(cryptofuzz::operation::BLS_MapToG1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::dontCompare(cryptofuzz::operation::BLS_MapToG2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::dontCompare(cryptofuzz::operation::BLS_IsG1OnCurve const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::dontCompare(cryptofuzz::operation::BLS_IsG2OnCurve const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::dontCompare(cryptofuzz::operation::BLS_GenerateKeyPair const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::dontCompare(cryptofuzz::operation::BLS_Decompress_G1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::dontCompare(cryptofuzz::operation::BLS_Compress_G1 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::dontCompare(cryptofuzz::operation::BLS_Decompress_G2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::dontCompare(cryptofuzz::operation::BLS_Compress_G2 const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::dontCompare(cryptofuzz::operation::BLS_G1_Add const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::dontCompare(cryptofuzz::operation::BLS_G1_Mul const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::dontCompare(cryptofuzz::operation::BLS_G1_IsEq const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::dontCompare(cryptofuzz::operation::BLS_G1_Neg const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::dontCompare(cryptofuzz::operation::BLS_G2_Add const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::dontCompare(cryptofuzz::operation::BLS_G2_Mul const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::dontCompare(cryptofuzz::operation::BLS_G2_IsEq const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::dontCompare(cryptofuzz::operation::BLS_G2_Neg const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::dontCompare(cryptofuzz::operation::Misc const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::dontCompare(cryptofuzz::operation::SR25519_Verify const&) const
1980
1981
template <>
1982
3.27k
bool ExecutorBase<component::Bignum, operation::BignumCalc>::dontCompare(const operation::BignumCalc& operation) const {
1983
3.27k
    if ( operation.calcOp.Get() == CF_CALCOP("Rand()") ) { return true; }
1984
3.26k
    if ( operation.calcOp.Get() == CF_CALCOP("Prime()") ) { return true; }
1985
1986
3.26k
    return false;
1987
3.26k
}
1988
1989
template <>
1990
498
bool ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::dontCompare(const operation::ECDSA_Sign& operation) const {
1991
498
    if (
1992
498
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
1993
498
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
1994
241
        if ( operation.UseRandomNonce() ) {
1995
            /* Don't compare ECDSA signatures comptued from a randomly generated nonce */
1996
145
            return true;
1997
145
        }
1998
241
    }
1999
2000
353
    return false;
2001
498
}
2002
2003
template <>
2004
0
bool ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::dontCompare(const operation::ECGDSA_Sign& operation) const {
2005
0
    if (
2006
0
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
2007
0
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
2008
0
        if ( operation.UseRandomNonce() ) {
2009
            /* Don't compare ECGDSA signatures comptued from a randomly generated nonce */
2010
0
            return true;
2011
0
        }
2012
0
    }
2013
2014
0
    return false;
2015
0
}
2016
2017
template <>
2018
0
bool ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::dontCompare(const operation::ECRDSA_Sign& operation) const {
2019
0
    if (
2020
0
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
2021
0
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
2022
0
        if ( operation.UseRandomNonce() ) {
2023
            /* Don't compare ECRDSA signatures comptued from a randomly generated nonce */
2024
0
            return true;
2025
0
        }
2026
0
    }
2027
2028
0
    return false;
2029
0
}
2030
2031
/* OpenSSL DES_EDE3_WRAP randomizes the IV, result is different each time */
2032
template <>
2033
0
bool ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>::dontCompare(const operation::SymmetricEncrypt& operation) const {
2034
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) { return true; }
2035
2036
0
    return false;
2037
0
}
2038
2039
template <>
2040
0
bool ExecutorBase<component::Cleartext, operation::SymmetricDecrypt>::dontCompare(const operation::SymmetricDecrypt& operation) const {
2041
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2042
2043
0
    return false;
2044
0
}
2045
2046
template <>
2047
0
bool ExecutorBase<component::MAC, operation::CMAC>::dontCompare(const operation::CMAC& operation) const {
2048
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2049
2050
0
    return false;
2051
0
}
2052
2053
template <>
2054
0
bool ExecutorBase<component::MAC, operation::HMAC>::dontCompare(const operation::HMAC& operation) const {
2055
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2056
2057
0
    return false;
2058
0
}
2059
2060
template <class ResultType, class OperationType>
2061
20.7k
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
20.7k
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
20.7k
    const auto filtered = filter(results);
2068
2069
20.7k
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
15.9k
        return;
2072
15.9k
    }
2073
2074
4.79k
    if ( dontCompare(operations[0].second) == true ) {
2075
154
        return;
2076
154
    }
2077
2078
11.2k
    for (size_t i = 1; i < filtered.size(); i++) {
2079
6.56k
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
6.56k
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
6.56k
        const bool equal = *prev == *cur;
2083
2084
6.56k
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
6.56k
    }
2101
4.64k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Digest>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Digest> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::HMAC>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::HMAC> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::UMAC>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::UMAC> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::CMAC>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::CMAC> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SymmetricEncrypt>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SymmetricEncrypt> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SymmetricDecrypt>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SymmetricDecrypt> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SCRYPT>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SCRYPT> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_HKDF>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_HKDF> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_TLS1_PRF>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_TLS1_PRF> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_PBKDF2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_ARGON2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_ARGON2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SSH>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SSH> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_X963>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_X963> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_BCRYPT>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_BCRYPT> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SP_800_108>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::KDF_SP_800_108> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_PrivateToPublic>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_PrivateToPublic> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
1.18k
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
1.18k
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
1.18k
    const auto filtered = filter(results);
2068
2069
1.18k
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
814
        return;
2072
814
    }
2073
2074
368
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
840
    for (size_t i = 1; i < filtered.size(); i++) {
2079
472
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
472
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
472
        const bool equal = *prev == *cur;
2083
2084
472
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
472
    }
2101
368
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_ValidatePubkey>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_ValidatePubkey> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
978
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
978
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
978
    const auto filtered = filter(results);
2068
2069
978
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
569
        return;
2072
569
    }
2073
2074
409
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
991
    for (size_t i = 1; i < filtered.size(); i++) {
2079
582
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
582
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
582
        const bool equal = *prev == *cur;
2083
2084
582
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
582
    }
2101
409
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
1.52k
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
1.52k
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
1.52k
    const auto filtered = filter(results);
2068
2069
1.52k
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
1.02k
        return;
2072
1.02k
    }
2073
2074
498
    if ( dontCompare(operations[0].second) == true ) {
2075
145
        return;
2076
145
    }
2077
2078
1.12k
    for (size_t i = 1; i < filtered.size(); i++) {
2079
769
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
769
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
769
        const bool equal = *prev == *cur;
2083
2084
769
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
769
    }
2101
353
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECGDSA_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECGDSA_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECRDSA_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECRDSA_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Schnorr_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Schnorr_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECDSA_Signature> > > > const&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
757
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
757
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
757
    const auto filtered = filter(results);
2068
2069
757
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
633
        return;
2072
633
    }
2073
2074
124
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
311
    for (size_t i = 1; i < filtered.size(); i++) {
2079
187
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
187
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
187
        const bool equal = *prev == *cur;
2083
2084
187
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
187
    }
2101
124
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECGDSA_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECGDSA_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECRDSA_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECRDSA_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Schnorr_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Schnorr_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Recover>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDSA_Recover> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDH_Derive>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECDH_Derive> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
103
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
103
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
103
    const auto filtered = filter(results);
2068
2069
103
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
91
        return;
2072
91
    }
2073
2074
12
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
37
    for (size_t i = 1; i < filtered.size(); i++) {
2079
25
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
25
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
25
        const bool equal = *prev == *cur;
2083
2084
25
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
25
    }
2101
12
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECIES_Encrypt>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECIES_Encrypt> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Ciphertext> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
182
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
182
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
182
    const auto filtered = filter(results);
2068
2069
182
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
171
        return;
2072
171
    }
2073
2074
11
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
27
    for (size_t i = 1; i < filtered.size(); i++) {
2079
16
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
16
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
16
        const bool equal = *prev == *cur;
2083
2084
16
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
16
    }
2101
11
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECIES_Decrypt>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECIES_Decrypt> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
132
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
132
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
132
    const auto filtered = filter(results);
2068
2069
132
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
132
        return;
2072
132
    }
2073
2074
0
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
0
    for (size_t i = 1; i < filtered.size(); i++) {
2079
0
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
0
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
0
        const bool equal = *prev == *cur;
2083
2084
0
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
0
    }
2101
0
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Add>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Add> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
783
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
783
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
783
    const auto filtered = filter(results);
2068
2069
783
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
767
        return;
2072
767
    }
2073
2074
16
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
45
    for (size_t i = 1; i < filtered.size(); i++) {
2079
29
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
29
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
29
        const bool equal = *prev == *cur;
2083
2084
29
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
29
    }
2101
16
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Mul>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Mul> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
711
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
711
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
711
    const auto filtered = filter(results);
2068
2069
711
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
681
        return;
2072
681
    }
2073
2074
30
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
78
    for (size_t i = 1; i < filtered.size(); i++) {
2079
48
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
48
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
48
        const bool equal = *prev == *cur;
2083
2084
48
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
48
    }
2101
30
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Neg>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Neg> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Dbl>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Dbl> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DH_Derive>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DH_Derive> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
484
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
484
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
484
    const auto filtered = filter(results);
2068
2069
484
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
436
        return;
2072
436
    }
2073
2074
48
    if ( dontCompare(operations[0].second) == true ) {
2075
0
        return;
2076
0
    }
2077
2078
153
    for (size_t i = 1; i < filtered.size(); i++) {
2079
105
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
105
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
105
        const bool equal = *prev == *cur;
2083
2084
105
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
105
    }
2101
48
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&, unsigned char const*, unsigned long) const
Line
Count
Source
2061
13.8k
void ExecutorBase<ResultType, OperationType>::compare(const std::vector< std::pair<std::shared_ptr<Module>, OperationType> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
2062
13.8k
    if ( results.size() < 2 ) {
2063
        /* Nothing to compare. Don't even bother filtering. */
2064
0
        return;
2065
0
    }
2066
2067
13.8k
    const auto filtered = filter(results);
2068
2069
13.8k
    if ( filtered.size() < 2 ) {
2070
        /* Nothing to compare */
2071
10.6k
        return;
2072
10.6k
    }
2073
2074
3.27k
    if ( dontCompare(operations[0].second) == true ) {
2075
9
        return;
2076
9
    }
2077
2078
7.60k
    for (size_t i = 1; i < filtered.size(); i++) {
2079
4.33k
        const std::optional<ResultType>& prev = filtered[i-1].second;
2080
4.33k
        const std::optional<ResultType>& cur = filtered[i].second;
2081
2082
4.33k
        const bool equal = *prev == *cur;
2083
2084
4.33k
        if ( !equal ) {
2085
            /* Reconstruct operation */
2086
0
            const auto op = getOp(nullptr, data, size);
2087
2088
0
            printf("Difference detected\n\n");
2089
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2090
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2091
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2092
2093
0
            abort(
2094
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2095
0
                    op.Name(),
2096
0
                    op.GetAlgorithmString(),
2097
0
                    "difference"
2098
0
            );
2099
0
        }
2100
4.33k
    }
2101
3.26k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc_Fp2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc_Fp2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc_Fp12>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BignumCalc_Fp12> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_PrivateToPublic>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_PrivateToPublic> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_PrivateToPublic_G2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_PrivateToPublic_G2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_Signature> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_BatchSign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_BatchSign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_BatchSignature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_BatchSignature> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_BatchVerify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_BatchVerify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Aggregate_G1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Aggregate_G1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Aggregate_G2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Aggregate_G2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Pairing>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Pairing> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MillerLoop>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MillerLoop> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_FinalExp>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_FinalExp> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::Fp12> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_HashToG1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_HashToG1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_HashToG2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_HashToG2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MapToG1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MapToG1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MapToG2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_MapToG2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_IsG1OnCurve>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_IsG1OnCurve> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_IsG2OnCurve>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_IsG2OnCurve> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_GenerateKeyPair>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_GenerateKeyPair> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_KeyPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BLS_KeyPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Decompress_G1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Decompress_G1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Compress_G1>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Compress_G1> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Bignum> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Decompress_G2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Decompress_G2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Compress_G2>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_Compress_G2> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Add>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Add> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Mul>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Mul> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_IsEq>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_IsEq> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Neg>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G1_Neg> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::BignumPair> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Add>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Add> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Mul>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Mul> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_IsEq>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_IsEq> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Neg>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::BLS_G2_Neg> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::G2> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Misc>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::Misc> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::Buffer> > > > const&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SR25519_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::SR25519_Verify> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<bool> > > > const&, unsigned char const*, unsigned long) const
2102
2103
template <class ResultType, class OperationType>
2104
0
void ExecutorBase<ResultType, OperationType>::abort(std::vector<std::string> moduleNames, const std::string operation, const std::string algorithm, const std::string reason) const {
2105
0
    std::sort(moduleNames.begin(), moduleNames.end());
2106
2107
0
    printf("Assertion failure: ");
2108
0
    for (const auto& moduleName : moduleNames) {
2109
0
        printf("%s-", moduleName.c_str());
2110
0
    }
2111
0
    printf("%s-%s-%s\n", operation.c_str(), algorithm.c_str(), reason.c_str());
2112
0
    fflush(stdout);
2113
2114
0
    ::abort();
2115
0
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::abort(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >) const
2116
2117
template <class ResultType, class OperationType>
2118
30.6k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
30.6k
    (void)parentDs;
2120
30.6k
    return std::move(op);
2121
30.6k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Digest) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::HMAC) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::UMAC) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::CMAC) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::SymmetricEncrypt) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::SymmetricDecrypt) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_SCRYPT) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_HKDF) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_TLS1_PRF) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_PBKDF) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_PBKDF1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_PBKDF2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_ARGON2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_SSH) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_X963) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_BCRYPT) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::KDF_SP_800_108) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_PrivateToPublic) const
Line
Count
Source
2118
1.58k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.58k
    (void)parentDs;
2120
1.58k
    return std::move(op);
2121
1.58k
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_ValidatePubkey) const
Line
Count
Source
2118
1.59k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.59k
    (void)parentDs;
2120
1.59k
    return std::move(op);
2121
1.59k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_GenerateKeyPair) const
Line
Count
Source
2118
1.91k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.91k
    (void)parentDs;
2120
1.91k
    return std::move(op);
2121
1.91k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDSA_Sign) const
Line
Count
Source
2118
2.88k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
2.88k
    (void)parentDs;
2120
2.88k
    return std::move(op);
2121
2.88k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECGDSA_Sign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECRDSA_Sign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Schnorr_Sign) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDSA_Verify) const
Line
Count
Source
2118
1.27k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.27k
    (void)parentDs;
2120
1.27k
    return std::move(op);
2121
1.27k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECGDSA_Verify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECRDSA_Verify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Schnorr_Verify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDSA_Recover) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDH_Derive) const
Line
Count
Source
2118
286
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
286
    (void)parentDs;
2120
286
    return std::move(op);
2121
286
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECIES_Encrypt) const
Line
Count
Source
2118
558
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
558
    (void)parentDs;
2120
558
    return std::move(op);
2121
558
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECIES_Decrypt) const
Line
Count
Source
2118
381
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
381
    (void)parentDs;
2120
381
    return std::move(op);
2121
381
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Add) const
Line
Count
Source
2118
1.22k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.22k
    (void)parentDs;
2120
1.22k
    return std::move(op);
2121
1.22k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Mul) const
Line
Count
Source
2118
1.09k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.09k
    (void)parentDs;
2120
1.09k
    return std::move(op);
2121
1.09k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Neg) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Dbl) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DH_GenerateKeyPair) const
Line
Count
Source
2118
1.05k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
1.05k
    (void)parentDs;
2120
1.05k
    return std::move(op);
2121
1.05k
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DH_Derive) const
Line
Count
Source
2118
892
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
892
    (void)parentDs;
2120
892
    return std::move(op);
2121
892
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BignumCalc) const
Line
Count
Source
2118
15.9k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2119
15.9k
    (void)parentDs;
2120
15.9k
    return std::move(op);
2121
15.9k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BignumCalc_Fp2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BignumCalc_Fp12) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_PrivateToPublic) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_PrivateToPublic_G2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Sign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Verify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_BatchSign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_BatchVerify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Aggregate_G1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Aggregate_G2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Pairing) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_MillerLoop) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_FinalExp) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_HashToG1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_HashToG2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_MapToG1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_MapToG2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_IsG1OnCurve) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_IsG2OnCurve) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_GenerateKeyPair) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Decompress_G1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Compress_G1) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Decompress_G2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_Compress_G2) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G1_Add) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G1_Mul) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G1_IsEq) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G1_Neg) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G2_Add) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G2_Mul) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G2_IsEq) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BLS_G2_Neg) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Misc) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::SR25519_Verify) const
2122
2123
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_381_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2124
0
    (void)parentDs;
2125
0
    op.modulo = modulo;
2126
0
    return op;
2127
0
}
2128
2129
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_381_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2130
0
    (void)parentDs;
2131
0
    op.modulo = modulo;
2132
0
    return op;
2133
0
}
2134
2135
0
operation::BignumCalc ExecutorBignumCalc_Mod_BN128_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2136
0
    (void)parentDs;
2137
0
    op.modulo = modulo;
2138
0
    return op;
2139
0
}
2140
2141
0
operation::BignumCalc ExecutorBignumCalc_Mod_BN128_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2142
0
    (void)parentDs;
2143
0
    op.modulo = modulo;
2144
0
    return op;
2145
0
}
2146
2147
0
operation::BignumCalc ExecutorBignumCalc_Mod_ED25519::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2148
0
    (void)parentDs;
2149
0
    op.modulo = modulo;
2150
0
    return op;
2151
0
}
2152
2153
0
operation::BignumCalc ExecutorBignumCalc_Mod_Edwards_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2154
0
    (void)parentDs;
2155
0
    op.modulo = modulo;
2156
0
    return op;
2157
0
}
2158
2159
0
operation::BignumCalc ExecutorBignumCalc_Mod_Edwards_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2160
0
    (void)parentDs;
2161
0
    op.modulo = modulo;
2162
0
    return op;
2163
0
}
2164
2165
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT4_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2166
0
    (void)parentDs;
2167
0
    op.modulo = modulo;
2168
0
    return op;
2169
0
}
2170
2171
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT4_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2172
0
    (void)parentDs;
2173
0
    op.modulo = modulo;
2174
0
    return op;
2175
0
}
2176
2177
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT6_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2178
0
    (void)parentDs;
2179
0
    op.modulo = modulo;
2180
0
    return op;
2181
0
}
2182
2183
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT6_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2184
0
    (void)parentDs;
2185
0
    op.modulo = modulo;
2186
0
    return op;
2187
0
}
2188
2189
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp64::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2190
0
    (void)parentDs;
2191
0
    op.modulo = modulo;
2192
0
    return op;
2193
0
}
2194
2195
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp128::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2196
0
    (void)parentDs;
2197
0
    op.modulo = modulo;
2198
0
    return op;
2199
0
}
2200
2201
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp256::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2202
0
    (void)parentDs;
2203
0
    op.modulo = modulo;
2204
0
    return op;
2205
0
}
2206
2207
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp512::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2208
0
    (void)parentDs;
2209
0
    op.modulo = modulo;
2210
0
    return op;
2211
0
}
2212
2213
0
operation::BignumCalc ExecutorBignumCalc_Mod_SECP256K1::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2214
0
    (void)parentDs;
2215
0
    op.modulo = modulo;
2216
0
    return op;
2217
0
}
2218
2219
0
operation::BignumCalc ExecutorBignumCalc_Mod_SECP256K1_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2220
0
    (void)parentDs;
2221
0
    op.modulo = modulo;
2222
0
    return op;
2223
0
}
2224
2225
template <class ResultType, class OperationType>
2226
30.8k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
30.8k
    Datasource ds(data, size);
2228
30.8k
    if ( parentDs != nullptr ) {
2229
30.8k
        auto modifier = parentDs->GetData(0);
2230
30.8k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
30.8k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
30.8k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.59k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.59k
    Datasource ds(data, size);
2228
1.59k
    if ( parentDs != nullptr ) {
2229
1.59k
        auto modifier = parentDs->GetData(0);
2230
1.59k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.59k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.59k
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.61k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.61k
    Datasource ds(data, size);
2228
1.61k
    if ( parentDs != nullptr ) {
2229
1.61k
        auto modifier = parentDs->GetData(0);
2230
1.61k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.61k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.61k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.92k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.92k
    Datasource ds(data, size);
2228
1.92k
    if ( parentDs != nullptr ) {
2229
1.92k
        auto modifier = parentDs->GetData(0);
2230
1.92k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.92k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.92k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
2.90k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
2.90k
    Datasource ds(data, size);
2228
2.90k
    if ( parentDs != nullptr ) {
2229
2.90k
        auto modifier = parentDs->GetData(0);
2230
2.90k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
2.90k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
2.90k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.29k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.29k
    Datasource ds(data, size);
2228
1.29k
    if ( parentDs != nullptr ) {
2229
1.29k
        auto modifier = parentDs->GetData(0);
2230
1.29k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.29k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.29k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
294
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
294
    Datasource ds(data, size);
2228
294
    if ( parentDs != nullptr ) {
2229
294
        auto modifier = parentDs->GetData(0);
2230
294
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
294
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
294
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
571
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
571
    Datasource ds(data, size);
2228
571
    if ( parentDs != nullptr ) {
2229
571
        auto modifier = parentDs->GetData(0);
2230
571
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
571
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
571
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
394
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
394
    Datasource ds(data, size);
2228
394
    if ( parentDs != nullptr ) {
2229
394
        auto modifier = parentDs->GetData(0);
2230
394
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
394
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
394
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.25k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.25k
    Datasource ds(data, size);
2228
1.25k
    if ( parentDs != nullptr ) {
2229
1.25k
        auto modifier = parentDs->GetData(0);
2230
1.25k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.25k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.25k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.11k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.11k
    Datasource ds(data, size);
2228
1.11k
    if ( parentDs != nullptr ) {
2229
1.11k
        auto modifier = parentDs->GetData(0);
2230
1.11k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.11k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.11k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
1.08k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
1.08k
    Datasource ds(data, size);
2228
1.08k
    if ( parentDs != nullptr ) {
2229
1.08k
        auto modifier = parentDs->GetData(0);
2230
1.08k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
1.08k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
1.08k
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
914
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
914
    Datasource ds(data, size);
2228
914
    if ( parentDs != nullptr ) {
2229
914
        auto modifier = parentDs->GetData(0);
2230
914
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
914
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
914
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2226
15.9k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2227
15.9k
    Datasource ds(data, size);
2228
15.9k
    if ( parentDs != nullptr ) {
2229
15.9k
        auto modifier = parentDs->GetData(0);
2230
15.9k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2231
15.9k
    } else {
2232
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2233
0
    }
2234
15.9k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
2235
2236
template <class ResultType, class OperationType>
2237
30.6k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
30.6k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
30.6k
    if ( options.forceModule != std::nullopt ) {
2242
30.3k
        moduleID = *options.forceModule;
2243
30.3k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
30.6k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
30.6k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
30.6k
    return modules.at(moduleID);
2255
30.6k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.58k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.58k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.58k
    if ( options.forceModule != std::nullopt ) {
2242
1.56k
        moduleID = *options.forceModule;
2243
1.56k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.58k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.58k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.58k
    return modules.at(moduleID);
2255
1.58k
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.59k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.59k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.59k
    if ( options.forceModule != std::nullopt ) {
2242
1.54k
        moduleID = *options.forceModule;
2243
1.54k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.59k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.59k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.59k
    return modules.at(moduleID);
2255
1.59k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.91k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.91k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.91k
    if ( options.forceModule != std::nullopt ) {
2242
1.89k
        moduleID = *options.forceModule;
2243
1.89k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.91k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.91k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.91k
    return modules.at(moduleID);
2255
1.91k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
2.88k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
2.88k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
2.88k
    if ( options.forceModule != std::nullopt ) {
2242
2.87k
        moduleID = *options.forceModule;
2243
2.87k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
2.88k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
2.88k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
2.88k
    return modules.at(moduleID);
2255
2.88k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.27k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.27k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.27k
    if ( options.forceModule != std::nullopt ) {
2242
1.26k
        moduleID = *options.forceModule;
2243
1.26k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.27k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.27k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.27k
    return modules.at(moduleID);
2255
1.27k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
286
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
286
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
286
    if ( options.forceModule != std::nullopt ) {
2242
276
        moduleID = *options.forceModule;
2243
276
    }
2244
2245
    /* Skip if this is a disabled module */
2246
286
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
286
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
286
    return modules.at(moduleID);
2255
286
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
558
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
558
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
558
    if ( options.forceModule != std::nullopt ) {
2242
541
        moduleID = *options.forceModule;
2243
541
    }
2244
2245
    /* Skip if this is a disabled module */
2246
558
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
558
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
558
    return modules.at(moduleID);
2255
558
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
381
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
381
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
381
    if ( options.forceModule != std::nullopt ) {
2242
364
        moduleID = *options.forceModule;
2243
364
    }
2244
2245
    /* Skip if this is a disabled module */
2246
381
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
381
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
381
    return modules.at(moduleID);
2255
381
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.22k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.22k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.22k
    if ( options.forceModule != std::nullopt ) {
2242
1.19k
        moduleID = *options.forceModule;
2243
1.19k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.22k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.22k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.22k
    return modules.at(moduleID);
2255
1.22k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.09k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.09k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.09k
    if ( options.forceModule != std::nullopt ) {
2242
1.08k
        moduleID = *options.forceModule;
2243
1.08k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.09k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.09k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.09k
    return modules.at(moduleID);
2255
1.09k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
1.05k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
1.05k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
1.05k
    if ( options.forceModule != std::nullopt ) {
2242
1.02k
        moduleID = *options.forceModule;
2243
1.02k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
1.05k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
1.05k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
1.05k
    return modules.at(moduleID);
2255
1.05k
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
892
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
892
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
892
    if ( options.forceModule != std::nullopt ) {
2242
862
        moduleID = *options.forceModule;
2243
862
    }
2244
2245
    /* Skip if this is a disabled module */
2246
892
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
892
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
892
    return modules.at(moduleID);
2255
892
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2237
15.9k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2238
15.9k
    auto moduleID = ds.Get<uint64_t>();
2239
2240
    /* Override the extracted module ID with the preferred one, if specified */
2241
15.9k
    if ( options.forceModule != std::nullopt ) {
2242
15.8k
        moduleID = *options.forceModule;
2243
15.8k
    }
2244
2245
    /* Skip if this is a disabled module */
2246
15.9k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2247
0
        return nullptr;
2248
0
    }
2249
2250
15.9k
    if ( modules.find(moduleID) == modules.end() ) {
2251
0
        return nullptr;
2252
0
    }
2253
2254
15.9k
    return modules.at(moduleID);
2255
15.9k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::getModule(fuzzing::datasource::Datasource&) const
2256
2257
template <class ResultType, class OperationType>
2258
23.5k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
23.5k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
23.5k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
30.8k
    do {
2264
30.8k
        auto op = getOp(&parentDs, data, size);
2265
30.8k
        auto module = getModule(parentDs);
2266
30.8k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
30.8k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
30.8k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
451
            break;
2275
451
        }
2276
30.8k
    } while ( parentDs.Get<bool>() == true );
2277
2278
23.5k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
23.5k
#if 1
2284
23.5k
    {
2285
23.5k
        std::set<uint64_t> moduleIDs;
2286
45.4k
        for (const auto& m : modules ) {
2287
45.4k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
45.4k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
45.4k
            moduleIDs.insert(moduleID);
2295
45.4k
        }
2296
2297
23.5k
        std::set<uint64_t> operationModuleIDs;
2298
29.4k
        for (const auto& op : operations) {
2299
29.4k
            operationModuleIDs.insert(op.first->ID);
2300
29.4k
        }
2301
2302
23.5k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
23.5k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
23.5k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
23.5k
        for (const auto& id : addModuleIDs) {
2307
22.7k
            operations.push_back({ modules.at(id), operations[0].second});
2308
22.7k
        }
2309
23.5k
    }
2310
23.5k
#endif
2311
2312
23.5k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
23.5k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
75.6k
    for (size_t i = 0; i < operations.size(); i++) {
2320
52.1k
        auto& operation = operations[i];
2321
2322
52.1k
        auto& module = operation.first;
2323
52.1k
        auto& op = operation.second;
2324
2325
52.1k
        if ( i > 0 ) {
2326
29.4k
            auto& prevModule = operations[i-1].first;
2327
29.4k
            auto& prevOp = operations[i].second;
2328
2329
29.4k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
6.72k
                auto& curModifier = op.modifier.GetVectorPtr();
2331
6.72k
                if ( curModifier.size() == 0 ) {
2332
1.22M
                    for (size_t j = 0; j < 512; j++) {
2333
1.21M
                        curModifier.push_back(1);
2334
1.21M
                    }
2335
4.34k
                } else {
2336
457k
                    for (auto& c : curModifier) {
2337
457k
                        c++;
2338
457k
                    }
2339
4.34k
                }
2340
6.72k
            }
2341
29.4k
        }
2342
2343
52.1k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
52.1k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
52.1k
        const auto& result = results.back();
2350
2351
52.1k
        if ( result.second != std::nullopt ) {
2352
18.1k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
18.1k
        }
2359
2360
52.1k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
52.1k
        if ( options.disableTests == false ) {
2369
52.1k
            tests::test(op, result.second);
2370
52.1k
        }
2371
2372
52.1k
        postprocess(module, op, result);
2373
52.1k
    }
2374
2375
23.5k
    if ( options.noCompare == false ) {
2376
22.7k
        compare(operations, results, data, size);
2377
22.7k
    }
2378
23.5k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
1.24k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
1.24k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
1.24k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.59k
    do {
2264
1.59k
        auto op = getOp(&parentDs, data, size);
2265
1.59k
        auto module = getModule(parentDs);
2266
1.59k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.59k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.59k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
17
            break;
2275
17
        }
2276
1.59k
    } while ( parentDs.Get<bool>() == true );
2277
2278
1.24k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
1.24k
#if 1
2284
1.24k
    {
2285
1.24k
        std::set<uint64_t> moduleIDs;
2286
2.36k
        for (const auto& m : modules ) {
2287
2.36k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
2.36k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
2.36k
            moduleIDs.insert(moduleID);
2295
2.36k
        }
2296
2297
1.24k
        std::set<uint64_t> operationModuleIDs;
2298
1.48k
        for (const auto& op : operations) {
2299
1.48k
            operationModuleIDs.insert(op.first->ID);
2300
1.48k
        }
2301
2302
1.24k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
1.24k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
1.24k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
1.24k
        for (const auto& id : addModuleIDs) {
2307
1.18k
            operations.push_back({ modules.at(id), operations[0].second});
2308
1.18k
        }
2309
1.24k
    }
2310
1.24k
#endif
2311
2312
1.24k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
1.24k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
3.91k
    for (size_t i = 0; i < operations.size(); i++) {
2320
2.67k
        auto& operation = operations[i];
2321
2322
2.67k
        auto& module = operation.first;
2323
2.67k
        auto& op = operation.second;
2324
2325
2.67k
        if ( i > 0 ) {
2326
1.48k
            auto& prevModule = operations[i-1].first;
2327
1.48k
            auto& prevOp = operations[i].second;
2328
2329
1.48k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
307
                auto& curModifier = op.modifier.GetVectorPtr();
2331
307
                if ( curModifier.size() == 0 ) {
2332
83.1k
                    for (size_t j = 0; j < 512; j++) {
2333
82.9k
                        curModifier.push_back(1);
2334
82.9k
                    }
2335
162
                } else {
2336
2.19k
                    for (auto& c : curModifier) {
2337
2.19k
                        c++;
2338
2.19k
                    }
2339
145
                }
2340
307
            }
2341
1.48k
        }
2342
2343
2.67k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
2.67k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
2.67k
        const auto& result = results.back();
2350
2351
2.67k
        if ( result.second != std::nullopt ) {
2352
1.16k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
1.16k
        }
2359
2360
2.67k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
2.67k
        if ( options.disableTests == false ) {
2369
2.67k
            tests::test(op, result.second);
2370
2.67k
        }
2371
2372
2.67k
        postprocess(module, op, result);
2373
2.67k
    }
2374
2375
1.24k
    if ( options.noCompare == false ) {
2376
1.18k
        compare(operations, results, data, size);
2377
1.18k
    }
2378
1.24k
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
1.07k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
1.07k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
1.07k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.61k
    do {
2264
1.61k
        auto op = getOp(&parentDs, data, size);
2265
1.61k
        auto module = getModule(parentDs);
2266
1.61k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.61k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.61k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
18
            break;
2275
18
        }
2276
1.61k
    } while ( parentDs.Get<bool>() == true );
2277
2278
1.07k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
1.07k
#if 1
2284
1.07k
    {
2285
1.07k
        std::set<uint64_t> moduleIDs;
2286
1.95k
        for (const auto& m : modules ) {
2287
1.95k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
1.95k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
1.95k
            moduleIDs.insert(moduleID);
2295
1.95k
        }
2296
2297
1.07k
        std::set<uint64_t> operationModuleIDs;
2298
1.44k
        for (const auto& op : operations) {
2299
1.44k
            operationModuleIDs.insert(op.first->ID);
2300
1.44k
        }
2301
2302
1.07k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
1.07k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
1.07k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
1.07k
        for (const auto& id : addModuleIDs) {
2307
978
            operations.push_back({ modules.at(id), operations[0].second});
2308
978
        }
2309
1.07k
    }
2310
1.07k
#endif
2311
2312
1.07k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
1.07k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
3.49k
    for (size_t i = 0; i < operations.size(); i++) {
2320
2.42k
        auto& operation = operations[i];
2321
2322
2.42k
        auto& module = operation.first;
2323
2.42k
        auto& op = operation.second;
2324
2325
2.42k
        if ( i > 0 ) {
2326
1.44k
            auto& prevModule = operations[i-1].first;
2327
1.44k
            auto& prevOp = operations[i].second;
2328
2329
1.44k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
464
                auto& curModifier = op.modifier.GetVectorPtr();
2331
464
                if ( curModifier.size() == 0 ) {
2332
85.6k
                    for (size_t j = 0; j < 512; j++) {
2333
85.5k
                        curModifier.push_back(1);
2334
85.5k
                    }
2335
297
                } else {
2336
6.85k
                    for (auto& c : curModifier) {
2337
6.85k
                        c++;
2338
6.85k
                    }
2339
297
                }
2340
464
            }
2341
1.44k
        }
2342
2343
2.42k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
2.42k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
2.42k
        const auto& result = results.back();
2350
2351
2.42k
        if ( result.second != std::nullopt ) {
2352
1.26k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
1.26k
        }
2359
2360
2.42k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
2.42k
        if ( options.disableTests == false ) {
2369
2.42k
            tests::test(op, result.second);
2370
2.42k
        }
2371
2372
2.42k
        postprocess(module, op, result);
2373
2.42k
    }
2374
2375
1.07k
    if ( options.noCompare == false ) {
2376
978
        compare(operations, results, data, size);
2377
978
    }
2378
1.07k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
1.38k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
1.38k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
1.38k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.92k
    do {
2264
1.92k
        auto op = getOp(&parentDs, data, size);
2265
1.92k
        auto module = getModule(parentDs);
2266
1.92k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.92k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.92k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
26
            break;
2275
26
        }
2276
1.92k
    } while ( parentDs.Get<bool>() == true );
2277
2278
1.38k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
1.38k
#if 1
2284
1.38k
    {
2285
1.38k
        std::set<uint64_t> moduleIDs;
2286
2.68k
        for (const auto& m : modules ) {
2287
2.68k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
2.68k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
2.68k
            moduleIDs.insert(moduleID);
2295
2.68k
        }
2296
2297
1.38k
        std::set<uint64_t> operationModuleIDs;
2298
1.84k
        for (const auto& op : operations) {
2299
1.84k
            operationModuleIDs.insert(op.first->ID);
2300
1.84k
        }
2301
2302
1.38k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
1.38k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
1.38k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
1.38k
        for (const auto& id : addModuleIDs) {
2307
1.34k
            operations.push_back({ modules.at(id), operations[0].second});
2308
1.34k
        }
2309
1.38k
    }
2310
1.38k
#endif
2311
2312
1.38k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
1.38k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
4.56k
    for (size_t i = 0; i < operations.size(); i++) {
2320
3.18k
        auto& operation = operations[i];
2321
2322
3.18k
        auto& module = operation.first;
2323
3.18k
        auto& op = operation.second;
2324
2325
3.18k
        if ( i > 0 ) {
2326
1.84k
            auto& prevModule = operations[i-1].first;
2327
1.84k
            auto& prevOp = operations[i].second;
2328
2329
1.84k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
500
                auto& curModifier = op.modifier.GetVectorPtr();
2331
500
                if ( curModifier.size() == 0 ) {
2332
55.9k
                    for (size_t j = 0; j < 512; j++) {
2333
55.8k
                        curModifier.push_back(1);
2334
55.8k
                    }
2335
391
                } else {
2336
29.8k
                    for (auto& c : curModifier) {
2337
29.8k
                        c++;
2338
29.8k
                    }
2339
391
                }
2340
500
            }
2341
1.84k
        }
2342
2343
3.18k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
3.18k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
3.18k
        const auto& result = results.back();
2350
2351
3.18k
        if ( result.second != std::nullopt ) {
2352
1.33k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
1.33k
        }
2359
2360
3.18k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
3.18k
        if ( options.disableTests == false ) {
2369
3.18k
            tests::test(op, result.second);
2370
3.18k
        }
2371
2372
3.18k
        postprocess(module, op, result);
2373
3.18k
    }
2374
2375
1.38k
    if ( options.noCompare == false ) {
2376
1.34k
        compare(operations, results, data, size);
2377
1.34k
    }
2378
1.38k
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
1.56k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
1.56k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
1.56k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
2.90k
    do {
2264
2.90k
        auto op = getOp(&parentDs, data, size);
2265
2.90k
        auto module = getModule(parentDs);
2266
2.90k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
2.90k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
2.90k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
114
            break;
2275
114
        }
2276
2.90k
    } while ( parentDs.Get<bool>() == true );
2277
2278
1.56k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
1.56k
#if 1
2284
1.56k
    {
2285
1.56k
        std::set<uint64_t> moduleIDs;
2286
3.04k
        for (const auto& m : modules ) {
2287
3.04k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
3.04k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
3.04k
            moduleIDs.insert(moduleID);
2295
3.04k
        }
2296
2297
1.56k
        std::set<uint64_t> operationModuleIDs;
2298
2.81k
        for (const auto& op : operations) {
2299
2.81k
            operationModuleIDs.insert(op.first->ID);
2300
2.81k
        }
2301
2302
1.56k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
1.56k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
1.56k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
1.56k
        for (const auto& id : addModuleIDs) {
2307
1.52k
            operations.push_back({ modules.at(id), operations[0].second});
2308
1.52k
        }
2309
1.56k
    }
2310
1.56k
#endif
2311
2312
1.56k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
1.56k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
5.90k
    for (size_t i = 0; i < operations.size(); i++) {
2320
4.33k
        auto& operation = operations[i];
2321
2322
4.33k
        auto& module = operation.first;
2323
4.33k
        auto& op = operation.second;
2324
2325
4.33k
        if ( i > 0 ) {
2326
2.81k
            auto& prevModule = operations[i-1].first;
2327
2.81k
            auto& prevOp = operations[i].second;
2328
2329
2.81k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
1.28k
                auto& curModifier = op.modifier.GetVectorPtr();
2331
1.28k
                if ( curModifier.size() == 0 ) {
2332
87.7k
                    for (size_t j = 0; j < 512; j++) {
2333
87.5k
                        curModifier.push_back(1);
2334
87.5k
                    }
2335
1.11k
                } else {
2336
58.7k
                    for (auto& c : curModifier) {
2337
58.7k
                        c++;
2338
58.7k
                    }
2339
1.11k
                }
2340
1.28k
            }
2341
2.81k
        }
2342
2343
4.33k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
4.33k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
4.33k
        const auto& result = results.back();
2350
2351
4.33k
        if ( result.second != std::nullopt ) {
2352
2.14k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
2.14k
        }
2359
2360
4.33k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
4.33k
        if ( options.disableTests == false ) {
2369
4.33k
            tests::test(op, result.second);
2370
4.33k
        }
2371
2372
4.33k
        postprocess(module, op, result);
2373
4.33k
    }
2374
2375
1.56k
    if ( options.noCompare == false ) {
2376
1.52k
        compare(operations, results, data, size);
2377
1.52k
    }
2378
1.56k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
794
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
794
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
794
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.29k
    do {
2264
1.29k
        auto op = getOp(&parentDs, data, size);
2265
1.29k
        auto module = getModule(parentDs);
2266
1.29k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.29k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.29k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
29
            break;
2275
29
        }
2276
1.29k
    } while ( parentDs.Get<bool>() == true );
2277
2278
794
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
794
#if 1
2284
794
    {
2285
794
        std::set<uint64_t> moduleIDs;
2286
1.51k
        for (const auto& m : modules ) {
2287
1.51k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
1.51k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
1.51k
            moduleIDs.insert(moduleID);
2295
1.51k
        }
2296
2297
794
        std::set<uint64_t> operationModuleIDs;
2298
1.21k
        for (const auto& op : operations) {
2299
1.21k
            operationModuleIDs.insert(op.first->ID);
2300
1.21k
        }
2301
2302
794
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
794
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
794
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
794
        for (const auto& id : addModuleIDs) {
2307
757
            operations.push_back({ modules.at(id), operations[0].second});
2308
757
        }
2309
794
    }
2310
794
#endif
2311
2312
794
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
794
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
2.76k
    for (size_t i = 0; i < operations.size(); i++) {
2320
1.97k
        auto& operation = operations[i];
2321
2322
1.97k
        auto& module = operation.first;
2323
1.97k
        auto& op = operation.second;
2324
2325
1.97k
        if ( i > 0 ) {
2326
1.21k
            auto& prevModule = operations[i-1].first;
2327
1.21k
            auto& prevOp = operations[i].second;
2328
2329
1.21k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
459
                auto& curModifier = op.modifier.GetVectorPtr();
2331
459
                if ( curModifier.size() == 0 ) {
2332
68.2k
                    for (size_t j = 0; j < 512; j++) {
2333
68.0k
                        curModifier.push_back(1);
2334
68.0k
                    }
2335
326
                } else {
2336
26.0k
                    for (auto& c : curModifier) {
2337
26.0k
                        c++;
2338
26.0k
                    }
2339
326
                }
2340
459
            }
2341
1.21k
        }
2342
2343
1.97k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
1.97k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
1.97k
        const auto& result = results.back();
2350
2351
1.97k
        if ( result.second != std::nullopt ) {
2352
739
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
739
        }
2359
2360
1.97k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
1.97k
        if ( options.disableTests == false ) {
2369
1.97k
            tests::test(op, result.second);
2370
1.97k
        }
2371
2372
1.97k
        postprocess(module, op, result);
2373
1.97k
    }
2374
2375
794
    if ( options.noCompare == false ) {
2376
757
        compare(operations, results, data, size);
2377
757
    }
2378
794
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
130
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
130
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
130
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
294
    do {
2264
294
        auto op = getOp(&parentDs, data, size);
2265
294
        auto module = getModule(parentDs);
2266
294
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
294
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
294
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
12
            break;
2275
12
        }
2276
294
    } while ( parentDs.Get<bool>() == true );
2277
2278
130
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
130
#if 1
2284
130
    {
2285
130
        std::set<uint64_t> moduleIDs;
2286
206
        for (const auto& m : modules ) {
2287
206
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
206
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
206
            moduleIDs.insert(moduleID);
2295
206
        }
2296
2297
130
        std::set<uint64_t> operationModuleIDs;
2298
233
        for (const auto& op : operations) {
2299
233
            operationModuleIDs.insert(op.first->ID);
2300
233
        }
2301
2302
130
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
130
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
130
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
130
        for (const auto& id : addModuleIDs) {
2307
103
            operations.push_back({ modules.at(id), operations[0].second});
2308
103
        }
2309
130
    }
2310
130
#endif
2311
2312
130
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
130
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
466
    for (size_t i = 0; i < operations.size(); i++) {
2320
336
        auto& operation = operations[i];
2321
2322
336
        auto& module = operation.first;
2323
336
        auto& op = operation.second;
2324
2325
336
        if ( i > 0 ) {
2326
233
            auto& prevModule = operations[i-1].first;
2327
233
            auto& prevOp = operations[i].second;
2328
2329
233
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
130
                auto& curModifier = op.modifier.GetVectorPtr();
2331
130
                if ( curModifier.size() == 0 ) {
2332
14.8k
                    for (size_t j = 0; j < 512; j++) {
2333
14.8k
                        curModifier.push_back(1);
2334
14.8k
                    }
2335
101
                } else {
2336
864
                    for (auto& c : curModifier) {
2337
864
                        c++;
2338
864
                    }
2339
101
                }
2340
130
            }
2341
233
        }
2342
2343
336
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
336
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
336
        const auto& result = results.back();
2350
2351
336
        if ( result.second != std::nullopt ) {
2352
43
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
43
        }
2359
2360
336
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
336
        if ( options.disableTests == false ) {
2369
336
            tests::test(op, result.second);
2370
336
        }
2371
2372
336
        postprocess(module, op, result);
2373
336
    }
2374
2375
130
    if ( options.noCompare == false ) {
2376
103
        compare(operations, results, data, size);
2377
103
    }
2378
130
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
228
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
228
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
228
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
571
    do {
2264
571
        auto op = getOp(&parentDs, data, size);
2265
571
        auto module = getModule(parentDs);
2266
571
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
571
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
571
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
32
            break;
2275
32
        }
2276
571
    } while ( parentDs.Get<bool>() == true );
2277
2278
228
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
228
#if 1
2284
228
    {
2285
228
        std::set<uint64_t> moduleIDs;
2286
364
        for (const auto& m : modules ) {
2287
364
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
364
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
364
            moduleIDs.insert(moduleID);
2295
364
        }
2296
2297
228
        std::set<uint64_t> operationModuleIDs;
2298
475
        for (const auto& op : operations) {
2299
475
            operationModuleIDs.insert(op.first->ID);
2300
475
        }
2301
2302
228
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
228
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
228
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
228
        for (const auto& id : addModuleIDs) {
2307
182
            operations.push_back({ modules.at(id), operations[0].second});
2308
182
        }
2309
228
    }
2310
228
#endif
2311
2312
228
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
228
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
885
    for (size_t i = 0; i < operations.size(); i++) {
2320
657
        auto& operation = operations[i];
2321
2322
657
        auto& module = operation.first;
2323
657
        auto& op = operation.second;
2324
2325
657
        if ( i > 0 ) {
2326
475
            auto& prevModule = operations[i-1].first;
2327
475
            auto& prevOp = operations[i].second;
2328
2329
475
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
293
                auto& curModifier = op.modifier.GetVectorPtr();
2331
293
                if ( curModifier.size() == 0 ) {
2332
31.2k
                    for (size_t j = 0; j < 512; j++) {
2333
31.2k
                        curModifier.push_back(1);
2334
31.2k
                    }
2335
232
                } else {
2336
93.8k
                    for (auto& c : curModifier) {
2337
93.8k
                        c++;
2338
93.8k
                    }
2339
232
                }
2340
293
            }
2341
475
        }
2342
2343
657
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
657
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
657
        const auto& result = results.back();
2350
2351
657
        if ( result.second != std::nullopt ) {
2352
55
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
55
        }
2359
2360
657
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
657
        if ( options.disableTests == false ) {
2369
657
            tests::test(op, result.second);
2370
657
        }
2371
2372
657
        postprocess(module, op, result);
2373
657
    }
2374
2375
228
    if ( options.noCompare == false ) {
2376
182
        compare(operations, results, data, size);
2377
182
    }
2378
228
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
178
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
178
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
178
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
394
    do {
2264
394
        auto op = getOp(&parentDs, data, size);
2265
394
        auto module = getModule(parentDs);
2266
394
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
394
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
394
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
16
            break;
2275
16
        }
2276
394
    } while ( parentDs.Get<bool>() == true );
2277
2278
178
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
178
#if 1
2284
178
    {
2285
178
        std::set<uint64_t> moduleIDs;
2286
264
        for (const auto& m : modules ) {
2287
264
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
264
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
264
            moduleIDs.insert(moduleID);
2295
264
        }
2296
2297
178
        std::set<uint64_t> operationModuleIDs;
2298
301
        for (const auto& op : operations) {
2299
301
            operationModuleIDs.insert(op.first->ID);
2300
301
        }
2301
2302
178
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
178
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
178
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
178
        for (const auto& id : addModuleIDs) {
2307
132
            operations.push_back({ modules.at(id), operations[0].second});
2308
132
        }
2309
178
    }
2310
178
#endif
2311
2312
178
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
178
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
611
    for (size_t i = 0; i < operations.size(); i++) {
2320
433
        auto& operation = operations[i];
2321
2322
433
        auto& module = operation.first;
2323
433
        auto& op = operation.second;
2324
2325
433
        if ( i > 0 ) {
2326
301
            auto& prevModule = operations[i-1].first;
2327
301
            auto& prevOp = operations[i].second;
2328
2329
301
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
169
                auto& curModifier = op.modifier.GetVectorPtr();
2331
169
                if ( curModifier.size() == 0 ) {
2332
24.1k
                    for (size_t j = 0; j < 512; j++) {
2333
24.0k
                        curModifier.push_back(1);
2334
24.0k
                    }
2335
122
                } else {
2336
26.6k
                    for (auto& c : curModifier) {
2337
26.6k
                        c++;
2338
26.6k
                    }
2339
122
                }
2340
169
            }
2341
301
        }
2342
2343
433
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
433
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
433
        const auto& result = results.back();
2350
2351
433
        if ( result.second != std::nullopt ) {
2352
2
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
2
        }
2359
2360
433
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
433
        if ( options.disableTests == false ) {
2369
433
            tests::test(op, result.second);
2370
433
        }
2371
2372
433
        postprocess(module, op, result);
2373
433
    }
2374
2375
178
    if ( options.noCompare == false ) {
2376
132
        compare(operations, results, data, size);
2377
132
    }
2378
178
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
888
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
888
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
888
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.25k
    do {
2264
1.25k
        auto op = getOp(&parentDs, data, size);
2265
1.25k
        auto module = getModule(parentDs);
2266
1.25k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.25k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.25k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
15
            break;
2275
15
        }
2276
1.25k
    } while ( parentDs.Get<bool>() == true );
2277
2278
888
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
888
#if 1
2284
888
    {
2285
888
        std::set<uint64_t> moduleIDs;
2286
1.56k
        for (const auto& m : modules ) {
2287
1.56k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
1.56k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
1.56k
            moduleIDs.insert(moduleID);
2295
1.56k
        }
2296
2297
888
        std::set<uint64_t> operationModuleIDs;
2298
1.05k
        for (const auto& op : operations) {
2299
1.05k
            operationModuleIDs.insert(op.first->ID);
2300
1.05k
        }
2301
2302
888
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
888
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
888
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
888
        for (const auto& id : addModuleIDs) {
2307
783
            operations.push_back({ modules.at(id), operations[0].second});
2308
783
        }
2309
888
    }
2310
888
#endif
2311
2312
888
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
888
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
2.72k
    for (size_t i = 0; i < operations.size(); i++) {
2320
1.83k
        auto& operation = operations[i];
2321
2322
1.83k
        auto& module = operation.first;
2323
1.83k
        auto& op = operation.second;
2324
2325
1.83k
        if ( i > 0 ) {
2326
1.05k
            auto& prevModule = operations[i-1].first;
2327
1.05k
            auto& prevOp = operations[i].second;
2328
2329
1.05k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
273
                auto& curModifier = op.modifier.GetVectorPtr();
2331
273
                if ( curModifier.size() == 0 ) {
2332
30.2k
                    for (size_t j = 0; j < 512; j++) {
2333
30.2k
                        curModifier.push_back(1);
2334
30.2k
                    }
2335
214
                } else {
2336
16.7k
                    for (auto& c : curModifier) {
2337
16.7k
                        c++;
2338
16.7k
                    }
2339
214
                }
2340
273
            }
2341
1.05k
        }
2342
2343
1.83k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
1.83k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
1.83k
        const auto& result = results.back();
2350
2351
1.83k
        if ( result.second != std::nullopt ) {
2352
60
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
60
        }
2359
2360
1.83k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
1.83k
        if ( options.disableTests == false ) {
2369
1.83k
            tests::test(op, result.second);
2370
1.83k
        }
2371
2372
1.83k
        postprocess(module, op, result);
2373
1.83k
    }
2374
2375
888
    if ( options.noCompare == false ) {
2376
783
        compare(operations, results, data, size);
2377
783
    }
2378
888
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
762
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
762
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
762
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.11k
    do {
2264
1.11k
        auto op = getOp(&parentDs, data, size);
2265
1.11k
        auto module = getModule(parentDs);
2266
1.11k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.11k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.11k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
21
            break;
2275
21
        }
2276
1.11k
    } while ( parentDs.Get<bool>() == true );
2277
2278
762
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
762
#if 1
2284
762
    {
2285
762
        std::set<uint64_t> moduleIDs;
2286
1.42k
        for (const auto& m : modules ) {
2287
1.42k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
1.42k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
1.42k
            moduleIDs.insert(moduleID);
2295
1.42k
        }
2296
2297
762
        std::set<uint64_t> operationModuleIDs;
2298
1.03k
        for (const auto& op : operations) {
2299
1.03k
            operationModuleIDs.insert(op.first->ID);
2300
1.03k
        }
2301
2302
762
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
762
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
762
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
762
        for (const auto& id : addModuleIDs) {
2307
711
            operations.push_back({ modules.at(id), operations[0].second});
2308
711
        }
2309
762
    }
2310
762
#endif
2311
2312
762
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
762
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
2.50k
    for (size_t i = 0; i < operations.size(); i++) {
2320
1.74k
        auto& operation = operations[i];
2321
2322
1.74k
        auto& module = operation.first;
2323
1.74k
        auto& op = operation.second;
2324
2325
1.74k
        if ( i > 0 ) {
2326
1.03k
            auto& prevModule = operations[i-1].first;
2327
1.03k
            auto& prevOp = operations[i].second;
2328
2329
1.03k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
319
                auto& curModifier = op.modifier.GetVectorPtr();
2331
319
                if ( curModifier.size() == 0 ) {
2332
22.5k
                    for (size_t j = 0; j < 512; j++) {
2333
22.5k
                        curModifier.push_back(1);
2334
22.5k
                    }
2335
275
                } else {
2336
57.1k
                    for (auto& c : curModifier) {
2337
57.1k
                        c++;
2338
57.1k
                    }
2339
275
                }
2340
319
            }
2341
1.03k
        }
2342
2343
1.74k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
1.74k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
1.74k
        const auto& result = results.back();
2350
2351
1.74k
        if ( result.second != std::nullopt ) {
2352
190
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
190
        }
2359
2360
1.74k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
1.74k
        if ( options.disableTests == false ) {
2369
1.74k
            tests::test(op, result.second);
2370
1.74k
        }
2371
2372
1.74k
        postprocess(module, op, result);
2373
1.74k
    }
2374
2375
762
    if ( options.noCompare == false ) {
2376
711
        compare(operations, results, data, size);
2377
711
    }
2378
762
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
747
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
747
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
747
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
1.08k
    do {
2264
1.08k
        auto op = getOp(&parentDs, data, size);
2265
1.08k
        auto module = getModule(parentDs);
2266
1.08k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
1.08k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
1.08k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
15
            break;
2275
15
        }
2276
1.08k
    } while ( parentDs.Get<bool>() == true );
2277
2278
747
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
747
#if 1
2284
747
    {
2285
747
        std::set<uint64_t> moduleIDs;
2286
1.33k
        for (const auto& m : modules ) {
2287
1.33k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
1.33k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
1.33k
            moduleIDs.insert(moduleID);
2295
1.33k
        }
2296
2297
747
        std::set<uint64_t> operationModuleIDs;
2298
965
        for (const auto& op : operations) {
2299
965
            operationModuleIDs.insert(op.first->ID);
2300
965
        }
2301
2302
747
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
747
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
747
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
747
        for (const auto& id : addModuleIDs) {
2307
668
            operations.push_back({ modules.at(id), operations[0].second});
2308
668
        }
2309
747
    }
2310
747
#endif
2311
2312
747
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
747
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
2.38k
    for (size_t i = 0; i < operations.size(); i++) {
2320
1.63k
        auto& operation = operations[i];
2321
2322
1.63k
        auto& module = operation.first;
2323
1.63k
        auto& op = operation.second;
2324
2325
1.63k
        if ( i > 0 ) {
2326
965
            auto& prevModule = operations[i-1].first;
2327
965
            auto& prevOp = operations[i].second;
2328
2329
965
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
297
                auto& curModifier = op.modifier.GetVectorPtr();
2331
297
                if ( curModifier.size() == 0 ) {
2332
101k
                    for (size_t j = 0; j < 512; j++) {
2333
101k
                        curModifier.push_back(1);
2334
101k
                    }
2335
198
                } else {
2336
3.64k
                    for (auto& c : curModifier) {
2337
3.64k
                        c++;
2338
3.64k
                    }
2339
99
                }
2340
297
            }
2341
965
        }
2342
2343
1.63k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
1.63k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
1.63k
        const auto& result = results.back();
2350
2351
1.63k
        if ( result.second != std::nullopt ) {
2352
68
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
68
        }
2359
2360
1.63k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
1.63k
        if ( options.disableTests == false ) {
2369
1.63k
            tests::test(op, result.second);
2370
1.63k
        }
2371
2372
1.63k
        postprocess(module, op, result);
2373
1.63k
    }
2374
2375
747
    if ( options.noCompare == false ) {
2376
668
        compare(operations, results, data, size);
2377
668
    }
2378
747
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
552
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
552
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
552
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
914
    do {
2264
914
        auto op = getOp(&parentDs, data, size);
2265
914
        auto module = getModule(parentDs);
2266
914
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
914
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
914
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
20
            break;
2275
20
        }
2276
914
    } while ( parentDs.Get<bool>() == true );
2277
2278
552
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
552
#if 1
2284
552
    {
2285
552
        std::set<uint64_t> moduleIDs;
2286
968
        for (const auto& m : modules ) {
2287
968
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
968
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
968
            moduleIDs.insert(moduleID);
2295
968
        }
2296
2297
552
        std::set<uint64_t> operationModuleIDs;
2298
791
        for (const auto& op : operations) {
2299
791
            operationModuleIDs.insert(op.first->ID);
2300
791
        }
2301
2302
552
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
552
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
552
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
552
        for (const auto& id : addModuleIDs) {
2307
484
            operations.push_back({ modules.at(id), operations[0].second});
2308
484
        }
2309
552
    }
2310
552
#endif
2311
2312
552
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
552
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
1.82k
    for (size_t i = 0; i < operations.size(); i++) {
2320
1.27k
        auto& operation = operations[i];
2321
2322
1.27k
        auto& module = operation.first;
2323
1.27k
        auto& op = operation.second;
2324
2325
1.27k
        if ( i > 0 ) {
2326
791
            auto& prevModule = operations[i-1].first;
2327
791
            auto& prevOp = operations[i].second;
2328
2329
791
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
307
                auto& curModifier = op.modifier.GetVectorPtr();
2331
307
                if ( curModifier.size() == 0 ) {
2332
57.9k
                    for (size_t j = 0; j < 512; j++) {
2333
57.8k
                        curModifier.push_back(1);
2334
57.8k
                    }
2335
194
                } else {
2336
2.58k
                    for (auto& c : curModifier) {
2337
2.58k
                        c++;
2338
2.58k
                    }
2339
194
                }
2340
307
            }
2341
791
        }
2342
2343
1.27k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
1.27k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
1.27k
        const auto& result = results.back();
2350
2351
1.27k
        if ( result.second != std::nullopt ) {
2352
276
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
276
        }
2359
2360
1.27k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
1.27k
        if ( options.disableTests == false ) {
2369
1.27k
            tests::test(op, result.second);
2370
1.27k
        }
2371
2372
1.27k
        postprocess(module, op, result);
2373
1.27k
    }
2374
2375
552
    if ( options.noCompare == false ) {
2376
484
        compare(operations, results, data, size);
2377
484
    }
2378
552
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2258
13.9k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2259
13.9k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2260
2261
13.9k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2262
2263
15.9k
    do {
2264
15.9k
        auto op = getOp(&parentDs, data, size);
2265
15.9k
        auto module = getModule(parentDs);
2266
15.9k
        if ( module == nullptr ) {
2267
0
            continue;
2268
0
        }
2269
2270
15.9k
        operations.push_back( {module, op} );
2271
2272
        /* Limit number of operations per run to prevent time-outs */
2273
15.9k
        if ( operations.size() == OperationType::MaxOperations() ) {
2274
116
            break;
2275
116
        }
2276
15.9k
    } while ( parentDs.Get<bool>() == true );
2277
2278
13.9k
    if ( operations.empty() == true ) {
2279
0
        return;
2280
0
    }
2281
2282
    /* Enable this to run every operation on every loaded module */
2283
13.9k
#if 1
2284
13.9k
    {
2285
13.9k
        std::set<uint64_t> moduleIDs;
2286
27.7k
        for (const auto& m : modules ) {
2287
27.7k
            const auto moduleID = m.first;
2288
2289
            /* Skip if this is a disabled module */
2290
27.7k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2291
0
                continue;
2292
0
            }
2293
2294
27.7k
            moduleIDs.insert(moduleID);
2295
27.7k
        }
2296
2297
13.9k
        std::set<uint64_t> operationModuleIDs;
2298
15.8k
        for (const auto& op : operations) {
2299
15.8k
            operationModuleIDs.insert(op.first->ID);
2300
15.8k
        }
2301
2302
13.9k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2303
13.9k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2304
13.9k
        addModuleIDs.resize(it - addModuleIDs.begin());
2305
2306
13.9k
        for (const auto& id : addModuleIDs) {
2307
13.8k
            operations.push_back({ modules.at(id), operations[0].second});
2308
13.8k
        }
2309
13.9k
    }
2310
13.9k
#endif
2311
2312
13.9k
    if ( operations.size() < options.minModules ) {
2313
0
        return;
2314
0
    }
2315
2316
13.9k
    if ( options.debug == true && !operations.empty() ) {
2317
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2318
0
    }
2319
43.6k
    for (size_t i = 0; i < operations.size(); i++) {
2320
29.6k
        auto& operation = operations[i];
2321
2322
29.6k
        auto& module = operation.first;
2323
29.6k
        auto& op = operation.second;
2324
2325
29.6k
        if ( i > 0 ) {
2326
15.8k
            auto& prevModule = operations[i-1].first;
2327
15.8k
            auto& prevOp = operations[i].second;
2328
2329
15.8k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2330
1.91k
                auto& curModifier = op.modifier.GetVectorPtr();
2331
1.91k
                if ( curModifier.size() == 0 ) {
2332
558k
                    for (size_t j = 0; j < 512; j++) {
2333
557k
                        curModifier.push_back(1);
2334
557k
                    }
2335
1.08k
                } else {
2336
132k
                    for (auto& c : curModifier) {
2337
132k
                        c++;
2338
132k
                    }
2339
828
                }
2340
1.91k
            }
2341
15.8k
        }
2342
2343
29.6k
        if ( options.debug == true ) {
2344
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2345
0
        }
2346
2347
29.6k
        results.push_back( {module, std::move(callModule(module, op))} );
2348
2349
29.6k
        const auto& result = results.back();
2350
2351
29.6k
        if ( result.second != std::nullopt ) {
2352
10.8k
            if ( options.jsonDumpFP != std::nullopt ) {
2353
0
                nlohmann::json j;
2354
0
                j["operation"] = op.ToJSON();
2355
0
                j["result"] = util::ToJSON(*result.second);
2356
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2357
0
            }
2358
10.8k
        }
2359
2360
29.6k
        if ( options.debug == true ) {
2361
0
            printf("Module %s result:\n\n%s\n\n",
2362
0
                    result.first->name.c_str(),
2363
0
                    result.second == std::nullopt ?
2364
0
                        "(empty)" :
2365
0
                        util::ToString(*result.second).c_str());
2366
0
        }
2367
2368
29.6k
        if ( options.disableTests == false ) {
2369
29.6k
            tests::test(op, result.second);
2370
29.6k
        }
2371
2372
29.6k
        postprocess(module, op, result);
2373
29.6k
    }
2374
2375
13.9k
    if ( options.noCompare == false ) {
2376
13.8k
        compare(operations, results, data, size);
2377
13.8k
    }
2378
13.9k
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
2379
2380
/* Explicit template instantiation */
2381
template class ExecutorBase<component::Digest, operation::Digest>;
2382
template class ExecutorBase<component::MAC, operation::HMAC>;
2383
template class ExecutorBase<component::MAC, operation::UMAC>;
2384
template class ExecutorBase<component::MAC, operation::CMAC>;
2385
template class ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>;
2386
template class ExecutorBase<component::Cleartext, operation::SymmetricDecrypt>;
2387
template class ExecutorBase<component::Key, operation::KDF_SCRYPT>;
2388
template class ExecutorBase<component::Key, operation::KDF_HKDF>;
2389
template class ExecutorBase<component::Key, operation::KDF_TLS1_PRF>;
2390
template class ExecutorBase<component::Key, operation::KDF_PBKDF>;
2391
template class ExecutorBase<component::Key, operation::KDF_PBKDF1>;
2392
template class ExecutorBase<component::Key, operation::KDF_PBKDF2>;
2393
template class ExecutorBase<component::Key, operation::KDF_ARGON2>;
2394
template class ExecutorBase<component::Key, operation::KDF_SSH>;
2395
template class ExecutorBase<component::Key, operation::KDF_X963>;
2396
template class ExecutorBase<component::Key, operation::KDF_BCRYPT>;
2397
template class ExecutorBase<component::Key, operation::KDF_SP_800_108>;
2398
template class ExecutorBase<component::ECC_PublicKey, operation::ECC_PrivateToPublic>;
2399
template class ExecutorBase<bool, operation::ECC_ValidatePubkey>;
2400
template class ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>;
2401
template class ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>;
2402
template class ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>;
2403
template class ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>;
2404
template class ExecutorBase<component::Schnorr_Signature, operation::Schnorr_Sign>;
2405
template class ExecutorBase<bool, operation::ECDSA_Verify>;
2406
template class ExecutorBase<bool, operation::ECGDSA_Verify>;
2407
template class ExecutorBase<bool, operation::ECRDSA_Verify>;
2408
template class ExecutorBase<bool, operation::Schnorr_Verify>;
2409
template class ExecutorBase<component::ECC_PublicKey, operation::ECDSA_Recover>;
2410
template class ExecutorBase<component::Secret, operation::ECDH_Derive>;
2411
template class ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>;
2412
template class ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>;
2413
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Add>;
2414
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Mul>;
2415
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Neg>;
2416
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Dbl>;
2417
template class ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>;
2418
template class ExecutorBase<component::Bignum, operation::DH_Derive>;
2419
template class ExecutorBase<component::Bignum, operation::BignumCalc>;
2420
template class ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>;
2421
template class ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>;
2422
template class ExecutorBase<component::BLS_PublicKey, operation::BLS_PrivateToPublic>;
2423
template class ExecutorBase<component::G2, operation::BLS_PrivateToPublic_G2>;
2424
template class ExecutorBase<component::BLS_Signature, operation::BLS_Sign>;
2425
template class ExecutorBase<bool, operation::BLS_Verify>;
2426
template class ExecutorBase<component::BLS_BatchSignature, operation::BLS_BatchSign>;
2427
template class ExecutorBase<bool, operation::BLS_BatchVerify>;
2428
template class ExecutorBase<component::G1, operation::BLS_Aggregate_G1>;
2429
template class ExecutorBase<component::G2, operation::BLS_Aggregate_G2>;
2430
template class ExecutorBase<component::Fp12, operation::BLS_Pairing>;
2431
template class ExecutorBase<component::Fp12, operation::BLS_MillerLoop>;
2432
template class ExecutorBase<component::Fp12, operation::BLS_FinalExp>;
2433
template class ExecutorBase<component::G1, operation::BLS_HashToG1>;
2434
template class ExecutorBase<component::G2, operation::BLS_HashToG2>;
2435
template class ExecutorBase<component::G1, operation::BLS_MapToG1>;
2436
template class ExecutorBase<component::G2, operation::BLS_MapToG2>;
2437
template class ExecutorBase<bool, operation::BLS_IsG1OnCurve>;
2438
template class ExecutorBase<bool, operation::BLS_IsG2OnCurve>;
2439
template class ExecutorBase<component::BLS_KeyPair, operation::BLS_GenerateKeyPair>;
2440
template class ExecutorBase<component::G1, operation::BLS_Decompress_G1>;
2441
template class ExecutorBase<component::Bignum, operation::BLS_Compress_G1>;
2442
template class ExecutorBase<component::G2, operation::BLS_Decompress_G2>;
2443
template class ExecutorBase<component::G1, operation::BLS_Compress_G2>;
2444
template class ExecutorBase<component::G1, operation::BLS_G1_Add>;
2445
template class ExecutorBase<component::G1, operation::BLS_G1_Mul>;
2446
template class ExecutorBase<bool, operation::BLS_G1_IsEq>;
2447
template class ExecutorBase<component::G1, operation::BLS_G1_Neg>;
2448
template class ExecutorBase<component::G2, operation::BLS_G2_Add>;
2449
template class ExecutorBase<component::G2, operation::BLS_G2_Mul>;
2450
template class ExecutorBase<bool, operation::BLS_G2_IsEq>;
2451
template class ExecutorBase<component::G2, operation::BLS_G2_Neg>;
2452
template class ExecutorBase<Buffer, operation::Misc>;
2453
template class ExecutorBase<bool, operation::SR25519_Verify>;
2454
2455
} /* namespace cryptofuzz */