Coverage Report

Created: 2023-02-22 06:39

/src/cryptofuzz/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
39.9k
#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
2.17k
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
2.17k
    (void)module;
53
2.17k
    (void)op;
54
55
2.17k
    if ( result.second != std::nullopt ) {
56
1.34k
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
57
1.34k
    }
58
2.17k
}
59
60
2.17k
template<> std::optional<component::Digest> ExecutorBase<component::Digest, operation::Digest>::callModule(std::shared_ptr<Module> module, operation::Digest& op) const {
61
2.17k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
62
63
2.09k
    return module->OpDigest(op);
64
2.17k
}
65
66
/* Specialization for operation::HMAC */
67
1.79k
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
1.79k
    (void)module;
69
1.79k
    (void)op;
70
71
1.79k
    if ( result.second != std::nullopt ) {
72
722
        fuzzing::memory::memory_test_msan(result.second->GetPtr(), result.second->GetSize());
73
722
    }
74
1.79k
}
75
76
1.79k
template<> std::optional<component::MAC> ExecutorBase<component::MAC, operation::HMAC>::callModule(std::shared_ptr<Module> module, operation::HMAC& op) const {
77
1.79k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
78
79
1.76k
    return module->OpHMAC(op);
80
1.79k
}
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.08k
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.08k
    (void)module;
411
412
2.08k
    if ( result.second != std::nullopt  ) {
413
1.20k
        const auto curveID = op.curveType.Get();
414
1.20k
        const auto privkey = op.priv.ToTrimmedString();
415
1.20k
        const auto pub_x = result.second->first.ToTrimmedString();
416
1.20k
        const auto pub_y = result.second->second.ToTrimmedString();
417
418
1.20k
        Pool_CurvePrivkey.Set({ curveID, privkey });
419
1.20k
        Pool_CurveKeypair.Set({ curveID, privkey, pub_x, pub_y });
420
1.20k
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
421
422
1.20k
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
423
1.20k
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
424
1.20k
    }
425
2.08k
}
426
427
2.08k
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.08k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
429
430
2.03k
    const size_t size = op.priv.ToTrimmedString().size();
431
432
2.03k
    if ( size == 0 || size > 4096 ) {
433
0
        return std::nullopt;
434
0
    }
435
436
2.03k
    return module->OpECC_PrivateToPublic(op);
437
2.03k
}
438
439
/* Specialization for operation::ECC_ValidatePubkey */
440
0
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
0
    (void)module;
442
0
    (void)op;
443
0
    (void)result;
444
0
}
445
446
0
template<> std::optional<bool> ExecutorBase<bool, operation::ECC_ValidatePubkey>::callModule(std::shared_ptr<Module> module, operation::ECC_ValidatePubkey& op) const {
447
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
448
449
0
    return module->OpECC_ValidatePubkey(op);
450
0
}
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
0
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
0
    (void)operations;
458
0
    (void)results;
459
0
    (void)data;
460
0
    (void)size;
461
0
}
462
463
0
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
0
    (void)module;
465
466
0
    if ( result.second != std::nullopt  ) {
467
0
        const auto curveID = op.curveType.Get();
468
0
        const auto privkey = result.second->priv.ToTrimmedString();
469
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
470
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
471
472
0
        Pool_CurvePrivkey.Set({ curveID, privkey });
473
0
        Pool_CurveKeypair.Set({ curveID, privkey, pub_x, pub_y });
474
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
475
0
    }
476
0
}
477
478
0
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
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
480
481
0
    return module->OpECC_GenerateKeyPair(op);
482
0
}
483
484
/* Specialization for operation::ECCSI_Sign */
485
0
template<> void ExecutorBase<component::ECCSI_Signature, operation::ECCSI_Sign>::postprocess(std::shared_ptr<Module> module, operation::ECCSI_Sign& op, const ExecutorBase<component::ECCSI_Signature, operation::ECCSI_Sign>::ResultPair& result) const {
486
0
    (void)module;
487
488
0
    if ( result.second != std::nullopt  ) {
489
0
        const auto curveID = op.curveType.Get();
490
0
        const auto cleartext = op.cleartext.ToHex();
491
0
        const auto id = op.id.ToHex();
492
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
493
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
494
0
        const auto pvt_x = result.second->pvt.first.ToTrimmedString();
495
0
        const auto pvt_y = result.second->pvt.second.ToTrimmedString();
496
0
        const auto sig_r = result.second->signature.first.ToTrimmedString();
497
0
        const auto sig_s = result.second->signature.second.ToTrimmedString();
498
499
0
        Pool_CurveECCSISignature.Set({
500
0
                curveID,
501
0
                cleartext,
502
0
                id,
503
0
                pub_x, pub_y,
504
0
                pvt_x, pvt_y,
505
0
                sig_r, sig_s});
506
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
507
0
        Pool_CurveECC_Point.Set({ curveID, pvt_x, pvt_y });
508
0
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
509
510
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
511
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
512
0
        if ( pvt_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pvt_x); }
513
0
        if ( pvt_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pvt_y); }
514
0
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
515
0
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
516
517
0
        {
518
0
            auto opVerify = operation::ECCSI_Verify(
519
0
                    op,
520
0
                    *(result.second),
521
0
                    op.modifier);
522
523
0
            const auto verifyResult = module->OpECCSI_Verify(opVerify);
524
0
            CF_ASSERT(
525
0
                    verifyResult == std::nullopt ||
526
0
                    *verifyResult == true,
527
0
                    "Cannot verify generated signature");
528
0
        }
529
0
    }
530
0
}
531
532
0
template<> std::optional<component::ECCSI_Signature> ExecutorBase<component::ECCSI_Signature, operation::ECCSI_Sign>::callModule(std::shared_ptr<Module> module, operation::ECCSI_Sign& op) const {
533
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
534
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
535
536
0
    const size_t size = op.priv.ToTrimmedString().size();
537
538
0
    if ( size == 0 || size > 4096 ) {
539
0
        return std::nullopt;
540
0
    }
541
542
0
    return module->OpECCSI_Sign(op);
543
0
}
544
545
/* Specialization for operation::ECDSA_Sign */
546
2.69k
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 {
547
2.69k
    (void)module;
548
549
2.69k
    if ( result.second != std::nullopt  ) {
550
895
        const auto curveID = op.curveType.Get();
551
895
        const auto cleartext = op.cleartext.ToHex();
552
895
        const auto pub_x = result.second->pub.first.ToTrimmedString();
553
895
        const auto pub_y = result.second->pub.second.ToTrimmedString();
554
895
        const auto sig_r = result.second->signature.first.ToTrimmedString();
555
895
        const auto sig_s = result.second->signature.second.ToTrimmedString();
556
557
895
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
558
895
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
559
895
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
560
561
895
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
562
895
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
563
895
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
564
895
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
565
566
895
        {
567
895
            auto opVerify = operation::ECDSA_Verify(
568
895
                    op,
569
895
                    *(result.second),
570
895
                    op.modifier);
571
572
895
            const auto verifyResult = module->OpECDSA_Verify(opVerify);
573
895
            CF_ASSERT(
574
895
                    verifyResult == std::nullopt ||
575
895
                    *verifyResult == true,
576
895
                    "Cannot verify generated signature");
577
895
        }
578
895
    }
579
2.69k
}
580
581
2.69k
template<> std::optional<component::ECDSA_Signature> ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECDSA_Sign& op) const {
582
2.69k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
583
2.67k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
584
585
2.63k
    const size_t size = op.priv.ToTrimmedString().size();
586
587
2.63k
    if ( size == 0 || size > 4096 ) {
588
0
        return std::nullopt;
589
0
    }
590
591
2.63k
    return module->OpECDSA_Sign(op);
592
2.63k
}
593
594
/* Specialization for operation::ECGDSA_Sign */
595
681
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 {
596
681
    (void)module;
597
598
681
    if ( result.second != std::nullopt  ) {
599
191
        const auto curveID = op.curveType.Get();
600
191
        const auto cleartext = op.cleartext.ToHex();
601
191
        const auto pub_x = result.second->pub.first.ToTrimmedString();
602
191
        const auto pub_y = result.second->pub.second.ToTrimmedString();
603
191
        const auto sig_r = result.second->signature.first.ToTrimmedString();
604
191
        const auto sig_s = result.second->signature.second.ToTrimmedString();
605
606
191
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
607
191
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
608
191
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
609
610
191
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
611
191
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
612
191
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
613
191
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
614
191
    }
615
681
}
616
617
681
template<> std::optional<component::ECGDSA_Signature> ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECGDSA_Sign& op) const {
618
681
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
619
659
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
620
621
639
    const size_t size = op.priv.ToTrimmedString().size();
622
623
639
    if ( size == 0 || size > 4096 ) {
624
0
        return std::nullopt;
625
0
    }
626
627
639
    return module->OpECGDSA_Sign(op);
628
639
}
629
630
/* Specialization for operation::ECRDSA_Sign */
631
513
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 {
632
513
    (void)module;
633
634
513
    if ( result.second != std::nullopt  ) {
635
108
        const auto curveID = op.curveType.Get();
636
108
        const auto cleartext = op.cleartext.ToHex();
637
108
        const auto pub_x = result.second->pub.first.ToTrimmedString();
638
108
        const auto pub_y = result.second->pub.second.ToTrimmedString();
639
108
        const auto sig_r = result.second->signature.first.ToTrimmedString();
640
108
        const auto sig_s = result.second->signature.second.ToTrimmedString();
641
642
108
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
643
108
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
644
108
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
645
646
108
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
647
108
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
648
108
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
649
108
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
650
108
    }
651
513
}
652
653
513
template<> std::optional<component::ECRDSA_Signature> ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::callModule(std::shared_ptr<Module> module, operation::ECRDSA_Sign& op) const {
654
513
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
655
486
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
656
657
474
    const size_t size = op.priv.ToTrimmedString().size();
658
659
474
    if ( size == 0 || size > 4096 ) {
660
0
        return std::nullopt;
661
0
    }
662
663
474
    return module->OpECRDSA_Sign(op);
664
474
}
665
666
/* Specialization for operation::Schnorr_Sign */
667
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 {
668
0
    (void)module;
669
670
0
    if ( result.second != std::nullopt  ) {
671
0
        const auto curveID = op.curveType.Get();
672
0
        const auto cleartext = op.cleartext.ToHex();
673
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
674
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
675
0
        const auto sig_r = result.second->signature.first.ToTrimmedString();
676
0
        const auto sig_s = result.second->signature.second.ToTrimmedString();
677
678
0
        Pool_CurveECDSASignature.Set({ curveID, cleartext, pub_x, pub_y, sig_r, sig_s});
679
0
        Pool_CurveECC_Point.Set({ curveID, pub_x, pub_y });
680
0
        Pool_CurveECC_Point.Set({ curveID, sig_r, sig_s });
681
682
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
683
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
684
0
        if ( sig_r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_r); }
685
0
        if ( sig_s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_s); }
686
0
    }
687
0
}
688
689
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 {
690
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
691
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
692
693
0
    const size_t size = op.priv.ToTrimmedString().size();
694
695
0
    if ( size == 0 || size > 4096 ) {
696
0
        return std::nullopt;
697
0
    }
698
699
0
    return module->OpSchnorr_Sign(op);
700
0
}
701
702
/* Specialization for operation::ECCSI_Verify */
703
0
template<> void ExecutorBase<bool, operation::ECCSI_Verify>::postprocess(std::shared_ptr<Module> module, operation::ECCSI_Verify& op, const ExecutorBase<bool, operation::ECCSI_Verify>::ResultPair& result) const {
704
0
    (void)module;
705
0
    (void)op;
706
0
    (void)result;
707
0
}
708
709
0
template<> std::optional<bool> ExecutorBase<bool, operation::ECCSI_Verify>::callModule(std::shared_ptr<Module> module, operation::ECCSI_Verify& op) const {
710
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
711
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
712
713
0
    return module->OpECCSI_Verify(op);
714
0
}
715
716
/* Specialization for operation::ECDSA_Verify */
717
1.18k
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 {
718
1.18k
    (void)module;
719
1.18k
    (void)op;
720
1.18k
    (void)result;
721
1.18k
}
722
723
1.18k
template<> std::optional<bool> ExecutorBase<bool, operation::ECDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECDSA_Verify& op) const {
724
1.18k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
725
1.14k
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
726
727
    /* Intentionally do not constrain the size of the public key or
728
     * signature (like we do for BignumCalc).
729
     *
730
     * If any large public key or signature causes a time-out (or
731
     * worse), this is something that needs attention;
732
     * because verifiers sometimes process untrusted public keys,
733
     * signatures or both, they should be resistant to bugs
734
     * arising from large inputs.
735
     */
736
737
1.13k
    return module->OpECDSA_Verify(op);
738
1.14k
}
739
740
/* Specialization for operation::ECGDSA_Verify */
741
595
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 {
742
595
    (void)module;
743
595
    (void)op;
744
595
    (void)result;
745
595
}
746
747
595
template<> std::optional<bool> ExecutorBase<bool, operation::ECGDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECGDSA_Verify& op) const {
748
595
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
749
571
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
750
751
    /* Intentionally do not constrain the size of the public key or
752
     * signature (like we do for BignumCalc).
753
     *
754
     * If any large public key or signature causes a time-out (or
755
     * worse), this is something that needs attention;
756
     * because verifiers sometimes process untrusted public keys,
757
     * signatures or both, they should be resistant to bugs
758
     * arising from large inputs.
759
     */
760
761
563
    return module->OpECGDSA_Verify(op);
762
571
}
763
764
/* Specialization for operation::ECRDSA_Verify */
765
436
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 {
766
436
    (void)module;
767
436
    (void)op;
768
436
    (void)result;
769
436
}
770
771
436
template<> std::optional<bool> ExecutorBase<bool, operation::ECRDSA_Verify>::callModule(std::shared_ptr<Module> module, operation::ECRDSA_Verify& op) const {
772
436
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
773
422
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
774
775
    /* Intentionally do not constrain the size of the public key or
776
     * signature (like we do for BignumCalc).
777
     *
778
     * If any large public key or signature causes a time-out (or
779
     * worse), this is something that needs attention;
780
     * because verifiers sometimes process untrusted public keys,
781
     * signatures or both, they should be resistant to bugs
782
     * arising from large inputs.
783
     */
784
785
413
    return module->OpECRDSA_Verify(op);
786
422
}
787
788
/* Specialization for operation::Schnorr_Verify */
789
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 {
790
0
    (void)module;
791
0
    (void)op;
792
0
    (void)result;
793
0
}
794
795
0
template<> std::optional<bool> ExecutorBase<bool, operation::Schnorr_Verify>::callModule(std::shared_ptr<Module> module, operation::Schnorr_Verify& op) const {
796
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
797
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
798
799
    /* Intentionally do not constrain the size of the public key or
800
     * signature (like we do for BignumCalc).
801
     *
802
     * If any large public key or signature causes a time-out (or
803
     * worse), this is something that needs attention;
804
     * because verifiers sometimes process untrusted public keys,
805
     * signatures or both, they should be resistant to bugs
806
     * arising from large inputs.
807
     */
808
809
0
    return module->OpSchnorr_Verify(op);
810
0
}
811
812
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 {
813
0
    (void)module;
814
0
    (void)op;
815
0
    (void)result;
816
0
}
817
818
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 {
819
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
820
0
    RETURN_IF_DISABLED(options.digests, op.digestType.Get());
821
822
0
    return module->OpECDSA_Recover(op);
823
0
}
824
825
/* Specialization for operation::DSA_Verify */
826
0
template<> void ExecutorBase<bool, operation::DSA_Verify>::updateExtraCounters(const uint64_t moduleID, operation::DSA_Verify& op) const {
827
0
    (void)moduleID;
828
0
    (void)op;
829
830
    /* TODO */
831
0
}
832
833
0
template<> void ExecutorBase<bool, operation::DSA_Verify>::postprocess(std::shared_ptr<Module> module, operation::DSA_Verify& op, const ExecutorBase<bool, operation::DSA_Verify>::ResultPair& result) const {
834
0
    (void)module;
835
0
    (void)op;
836
0
    (void)result;
837
0
}
838
839
0
template<> std::optional<bool> ExecutorBase<bool, operation::DSA_Verify>::callModule(std::shared_ptr<Module> module, operation::DSA_Verify& op) const {
840
0
    const std::vector<size_t> sizes = {
841
0
        op.parameters.p.ToTrimmedString().size(),
842
0
        op.parameters.q.ToTrimmedString().size(),
843
0
        op.parameters.g.ToTrimmedString().size(),
844
0
        op.pub.ToTrimmedString().size(),
845
0
        op.signature.first.ToTrimmedString().size(),
846
0
        op.signature.second.ToTrimmedString().size(),
847
0
    };
848
849
0
    for (const auto& size : sizes) {
850
0
        if ( size == 0 || size > 4096 ) {
851
0
            return std::nullopt;
852
0
        }
853
0
    }
854
855
0
    return module->OpDSA_Verify(op);
856
0
}
857
858
/* Specialization for operation::DSA_Sign */
859
/* Do not compare DSA_Sign results, because the result can be produced indeterministically */
860
template <>
861
0
void ExecutorBase<component::DSA_Signature, operation::DSA_Sign>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::DSA_Sign> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
862
0
    (void)operations;
863
0
    (void)results;
864
0
    (void)data;
865
0
    (void)size;
866
0
}
867
0
template<> void ExecutorBase<component::DSA_Signature, operation::DSA_Sign>::updateExtraCounters(const uint64_t moduleID, operation::DSA_Sign& op) const {
868
0
    (void)moduleID;
869
0
    (void)op;
870
871
    /* TODO */
872
0
}
873
874
0
template<> void ExecutorBase<component::DSA_Signature, operation::DSA_Sign>::postprocess(std::shared_ptr<Module> module, operation::DSA_Sign& op, const ExecutorBase<component::DSA_Signature, operation::DSA_Sign>::ResultPair& result) const {
875
0
    (void)module;
876
0
    (void)op;
877
0
    if ( result.second != std::nullopt ) {
878
0
        const auto cleartext = op.cleartext.ToHex();
879
0
        const auto p = op.parameters.p.ToTrimmedString();
880
0
        const auto q = op.parameters.q.ToTrimmedString();
881
0
        const auto g = op.parameters.g.ToTrimmedString();
882
0
        const auto r = result.second->signature.first.ToTrimmedString();
883
0
        const auto s = result.second->signature.second.ToTrimmedString();
884
0
        const auto pub = result.second->pub.ToTrimmedString();
885
886
0
        Pool_DSASignature.Set({
887
0
                cleartext,
888
0
                p,
889
0
                q,
890
0
                g,
891
0
                pub,
892
0
                r,
893
0
                s
894
0
        });
895
896
0
        if ( r.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(r); }
897
0
        if ( s.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(s); }
898
0
    }
899
0
}
900
901
0
template<> std::optional<component::DSA_Signature> ExecutorBase<component::DSA_Signature, operation::DSA_Sign>::callModule(std::shared_ptr<Module> module, operation::DSA_Sign& op) const {
902
0
    const std::vector<size_t> sizes = {
903
0
        op.parameters.p.ToTrimmedString().size(),
904
0
        op.parameters.q.ToTrimmedString().size(),
905
0
        op.parameters.g.ToTrimmedString().size(),
906
0
        op.priv.ToTrimmedString().size(),
907
0
    };
908
909
0
    for (const auto& size : sizes) {
910
0
        if ( size == 0 || size > 4096 ) {
911
0
            return std::nullopt;
912
0
        }
913
0
    }
914
915
0
    return module->OpDSA_Sign(op);
916
0
}
917
918
/* Specialization for operation::DSA_PrivateToPublic */
919
920
0
template<> void ExecutorBase<component::Bignum, operation::DSA_PrivateToPublic>::updateExtraCounters(const uint64_t moduleID, operation::DSA_PrivateToPublic& op) const {
921
0
    (void)moduleID;
922
0
    (void)op;
923
924
    /* TODO */
925
0
}
926
927
0
template<> void ExecutorBase<component::Bignum, operation::DSA_PrivateToPublic>::postprocess(std::shared_ptr<Module> module, operation::DSA_PrivateToPublic& op, const ExecutorBase<component::Bignum, operation::DSA_PrivateToPublic>::ResultPair& result) const {
928
0
    (void)result;
929
0
    (void)module;
930
0
    if ( result.second != std::nullopt ) {
931
        //Pool_DSA_PubPriv.Set({pub, priv});
932
0
    }
933
0
}
934
935
0
template<> std::optional<component::Bignum> ExecutorBase<component::Bignum, operation::DSA_PrivateToPublic>::callModule(std::shared_ptr<Module> module, operation::DSA_PrivateToPublic& op) const {
936
0
    return module->OpDSA_PrivateToPublic(op);
937
0
}
938
939
/* Specialization for operation::DSA_GenerateKeyPair */
940
941
/* Do not compare DSA_GenerateKeyPair results, because the result can be produced indeterministically */
942
template <>
943
0
void ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::DSA_GenerateKeyPair> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
944
0
    (void)operations;
945
0
    (void)results;
946
0
    (void)data;
947
0
    (void)size;
948
0
}
949
950
0
template<> void ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>::updateExtraCounters(const uint64_t moduleID, operation::DSA_GenerateKeyPair& op) const {
951
0
    (void)moduleID;
952
0
    (void)op;
953
954
    /* TODO */
955
0
}
956
957
0
template<> void ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>::postprocess(std::shared_ptr<Module> module, operation::DSA_GenerateKeyPair& op, const ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>::ResultPair& result) const {
958
0
    (void)result;
959
0
    (void)module;
960
0
    if ( result.second != std::nullopt && (PRNG() % 4) == 0 ) {
961
0
        const auto priv = result.second->first.ToTrimmedString();
962
0
        const auto pub = result.second->second.ToTrimmedString();
963
964
0
        Pool_DSA_PubPriv.Set({pub, priv});
965
0
    }
966
0
}
967
968
0
template<> std::optional<component::DSA_KeyPair> ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>::callModule(std::shared_ptr<Module> module, operation::DSA_GenerateKeyPair& op) const {
969
0
    const std::vector<size_t> sizes = {
970
0
        op.p.ToTrimmedString().size(),
971
0
        op.q.ToTrimmedString().size(),
972
0
        op.g.ToTrimmedString().size(),
973
0
    };
974
975
0
    for (const auto& size : sizes) {
976
0
        if ( size == 0 || size > 4096 ) {
977
0
            return std::nullopt;
978
0
        }
979
0
    }
980
981
0
    return module->OpDSA_GenerateKeyPair(op);
982
0
}
983
984
/* Specialization for operation::DSA_GenerateParameters */
985
986
/* Do not compare DSA_GenerateParameters results, because the result can be produced indeterministically */
987
template <>
988
0
void ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::DSA_GenerateParameters> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
989
0
    (void)operations;
990
0
    (void)results;
991
0
    (void)data;
992
0
    (void)size;
993
0
}
994
995
0
template<> void ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>::updateExtraCounters(const uint64_t moduleID, operation::DSA_GenerateParameters& op) const {
996
0
    (void)moduleID;
997
0
    (void)op;
998
999
    /* TODO */
1000
0
}
1001
1002
0
template<> void ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>::postprocess(std::shared_ptr<Module> module, operation::DSA_GenerateParameters& op, const ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>::ResultPair& result) const {
1003
0
    (void)result;
1004
0
    (void)module;
1005
0
    if ( result.second != std::nullopt && (PRNG() % 4) == 0 ) {
1006
0
        const auto P = result.second->p.ToTrimmedString();
1007
0
        const auto Q = result.second->q.ToTrimmedString();
1008
0
        const auto G = result.second->g.ToTrimmedString();
1009
1010
0
        Pool_DSA_PQG.Set({P, Q, G});
1011
1012
0
        if ( P.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(P); }
1013
0
        if ( Q.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(Q); }
1014
0
        if ( G.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(G); }
1015
0
    }
1016
0
}
1017
1018
0
template<> std::optional<component::DSA_Parameters> ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>::callModule(std::shared_ptr<Module> module, operation::DSA_GenerateParameters& op) const {
1019
0
    return module->OpDSA_GenerateParameters(op);
1020
0
}
1021
1022
/* Specialization for operation::ECDH_Derive */
1023
351
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 {
1024
351
    (void)module;
1025
351
    (void)op;
1026
351
    (void)result;
1027
351
}
1028
1029
351
template<> std::optional<component::Secret> ExecutorBase<component::Secret, operation::ECDH_Derive>::callModule(std::shared_ptr<Module> module, operation::ECDH_Derive& op) const {
1030
351
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1031
1032
327
    return module->OpECDH_Derive(op);
1033
351
}
1034
1035
/* Specialization for operation::ECIES_Encrypt */
1036
template <>
1037
0
void ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>::compare(const std::vector< std::pair<std::shared_ptr<Module>, operation::ECIES_Encrypt> >& operations, const ResultSet& results, const uint8_t* data, const size_t size) const {
1038
0
    (void)operations;
1039
0
    (void)results;
1040
0
    (void)data;
1041
0
    (void)size;
1042
0
}
1043
0
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 {
1044
0
    (void)module;
1045
0
    (void)op;
1046
0
    (void)result;
1047
0
}
1048
1049
0
template<> std::optional<component::Ciphertext> ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>::callModule(std::shared_ptr<Module> module, operation::ECIES_Encrypt& op) const {
1050
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1051
1052
0
    return module->OpECIES_Encrypt(op);
1053
0
}
1054
1055
/* Specialization for operation::ECIES_Decrypt */
1056
0
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 {
1057
0
    (void)module;
1058
0
    (void)op;
1059
0
    (void)result;
1060
0
}
1061
1062
0
template<> std::optional<component::Cleartext> ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>::callModule(std::shared_ptr<Module> module, operation::ECIES_Decrypt& op) const {
1063
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1064
1065
0
    return module->OpECIES_Decrypt(op);
1066
0
}
1067
1068
/* Specialization for operation::ECC_Point_Add */
1069
555
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 {
1070
555
    (void)module;
1071
1072
555
    if ( result.second != std::nullopt  ) {
1073
20
        const auto curveID = op.curveType.Get();
1074
20
        const auto x = result.second->first.ToTrimmedString();
1075
20
        const auto y = result.second->second.ToTrimmedString();
1076
1077
20
        Pool_CurveECC_Point.Set({ curveID, x, y });
1078
1079
20
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
1080
20
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
1081
20
    }
1082
555
}
1083
1084
555
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 {
1085
555
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1086
1087
531
    return module->OpECC_Point_Add(op);
1088
555
}
1089
1090
/* Specialization for operation::ECC_Point_Mul */
1091
1.30k
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 {
1092
1.30k
    (void)module;
1093
1094
1.30k
    if ( result.second != std::nullopt  ) {
1095
187
        const auto curveID = op.curveType.Get();
1096
187
        const auto x = result.second->first.ToTrimmedString();
1097
187
        const auto y = result.second->second.ToTrimmedString();
1098
1099
187
        Pool_CurveECC_Point.Set({ curveID, x, y });
1100
1101
187
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
1102
187
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
1103
187
    }
1104
1.30k
}
1105
1106
1.30k
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 {
1107
1.30k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1108
1109
1.27k
    return module->OpECC_Point_Mul(op);
1110
1.30k
}
1111
1112
/* Specialization for operation::ECC_Point_Neg */
1113
384
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 {
1114
384
    (void)module;
1115
1116
384
    if ( result.second != std::nullopt  ) {
1117
29
        const auto curveID = op.curveType.Get();
1118
29
        const auto x = result.second->first.ToTrimmedString();
1119
29
        const auto y = result.second->second.ToTrimmedString();
1120
1121
29
        Pool_CurveECC_Point.Set({ curveID, x, y });
1122
1123
29
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
1124
29
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
1125
29
    }
1126
384
}
1127
1128
384
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 {
1129
384
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1130
1131
353
    return module->OpECC_Point_Neg(op);
1132
384
}
1133
1134
/* Specialization for operation::ECC_Point_Dbl */
1135
1.14k
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 {
1136
1.14k
    (void)module;
1137
1138
1.14k
    if ( result.second != std::nullopt  ) {
1139
72
        const auto curveID = op.curveType.Get();
1140
72
        const auto x = result.second->first.ToTrimmedString();
1141
72
        const auto y = result.second->second.ToTrimmedString();
1142
1143
72
        Pool_CurveECC_Point.Set({ curveID, x, y });
1144
1145
72
        if ( x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(x); }
1146
72
        if ( y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(y); }
1147
72
    }
1148
1.14k
}
1149
1150
1.14k
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 {
1151
1.14k
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1152
1153
1.12k
    return module->OpECC_Point_Dbl(op);
1154
1.14k
}
1155
1156
/* Specialization for operation::ECC_Point_Cmp */
1157
0
template<> void ExecutorBase<bool, operation::ECC_Point_Cmp>::postprocess(std::shared_ptr<Module> module, operation::ECC_Point_Cmp& op, const ExecutorBase<bool, operation::ECC_Point_Cmp>::ResultPair& result) const {
1158
0
    (void)module;
1159
0
    (void)result;
1160
0
}
1161
1162
0
template<> std::optional<bool> ExecutorBase<bool, operation::ECC_Point_Cmp>::callModule(std::shared_ptr<Module> module, operation::ECC_Point_Cmp& op) const {
1163
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1164
1165
0
    return module->OpECC_Point_Cmp(op);
1166
0
}
1167
1168
/* Specialization for operation::DH_Derive */
1169
0
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 {
1170
0
    (void)module;
1171
0
    (void)op;
1172
0
    (void)result;
1173
0
}
1174
1175
0
template<> std::optional<component::Bignum> ExecutorBase<component::Bignum, operation::DH_Derive>::callModule(std::shared_ptr<Module> module, operation::DH_Derive& op) const {
1176
0
    if ( op.prime.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1177
0
    if ( op.base.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1178
0
    if ( op.pub.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1179
0
    if ( op.priv.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1180
1181
0
    return module->OpDH_Derive(op);
1182
0
}
1183
1184
/* Specialization for operation::DH_GenerateKeyPair */
1185
0
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 {
1186
0
    (void)result;
1187
0
    (void)op;
1188
0
    (void)module;
1189
1190
0
    if ( result.second != std::nullopt && (PRNG() % 4) == 0 ) {
1191
0
        const auto priv = result.second->first.ToTrimmedString();
1192
0
        const auto pub = result.second->second.ToTrimmedString();
1193
1194
0
        Pool_DH_PrivateKey.Set(priv);
1195
0
        Pool_DH_PublicKey.Set(pub);
1196
0
    }
1197
0
}
1198
1199
0
template<> std::optional<component::DH_KeyPair> ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>::callModule(std::shared_ptr<Module> module, operation::DH_GenerateKeyPair& op) const {
1200
0
    if ( op.prime.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1201
0
    if ( op.base.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1202
1203
0
    return module->OpDH_GenerateKeyPair(op);
1204
0
}
1205
1206
/* Specialization for operation::BignumCalc */
1207
18.1k
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 {
1208
18.1k
    (void)module;
1209
18.1k
    (void)op;
1210
1211
18.1k
    if ( result.second != std::nullopt  ) {
1212
12.5k
        const auto bignum = result.second->ToTrimmedString();
1213
1214
12.5k
        if ( bignum.size() <= config::kMaxBignumSize ) {
1215
12.1k
            Pool_Bignum.Set(bignum);
1216
12.1k
            if ( op.calcOp.Is(CF_CALCOP("Prime()")) ) {
1217
0
                Pool_Bignum_Primes.Set(bignum);
1218
0
            }
1219
12.1k
        }
1220
12.5k
        if ( op.calcOp.Is(CF_CALCOP("IsPrime(A)")) ) {
1221
0
            if ( bignum == "1" ) {
1222
0
                Pool_Bignum_Primes.Set(op.bn0.ToTrimmedString());
1223
0
            }
1224
0
        }
1225
12.5k
    }
1226
18.1k
}
1227
1228
18.1k
std::optional<component::Bignum> ExecutorBignumCalc::callModule(std::shared_ptr<Module> module, operation::BignumCalc& op) const {
1229
18.1k
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
1230
1231
    /* Prevent timeouts */
1232
18.1k
    if ( op.bn0.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1233
18.1k
    if ( op.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1234
18.1k
    if ( op.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1235
18.1k
    if ( op.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1236
1237
18.1k
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
1238
0
        return std::nullopt;
1239
0
    }
1240
1241
18.1k
    switch ( op.calcOp.Get() ) {
1242
0
        case    CF_CALCOP("SetBit(A,B)"):
1243
            /* Don't allow setting very high bit positions (risk of memory exhaustion) */
1244
0
            if ( op.bn1.GetSize() > 4 ) {
1245
0
                return std::nullopt;
1246
0
            }
1247
0
            break;
1248
0
        case    CF_CALCOP("Exp(A,B)"):
1249
0
            if ( op.bn0.GetSize() > 5 || op.bn1.GetSize() > 2 ) {
1250
0
                return std::nullopt;
1251
0
            }
1252
0
            break;
1253
0
        case    CF_CALCOP("ModLShift(A,B,C)"):
1254
0
            if ( op.bn1.GetSize() > 4 ) {
1255
0
                return std::nullopt;
1256
0
            }
1257
0
            break;
1258
0
        case    CF_CALCOP("Exp2(A)"):
1259
0
            if ( op.bn0.GetSize() > 4 ) {
1260
0
                return std::nullopt;
1261
0
            }
1262
0
            break;
1263
18.1k
    }
1264
1265
18.1k
    return module->OpBignumCalc(op);
1266
18.1k
}
1267
1268
/* Specialization for operation::BignumCalc_Fp2 */
1269
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 {
1270
0
    (void)module;
1271
0
    (void)op;
1272
1273
0
    if ( result.second != std::nullopt  ) {
1274
0
        const auto bignum_first = result.second->first.ToTrimmedString();
1275
0
        const auto bignum_second = result.second->second.ToTrimmedString();
1276
1277
0
        if ( bignum_first.size() <= config::kMaxBignumSize ) {
1278
0
            Pool_Bignum.Set(bignum_first);
1279
0
        }
1280
0
        if ( bignum_second.size() <= config::kMaxBignumSize ) {
1281
0
            Pool_Bignum.Set(bignum_second);
1282
0
        }
1283
0
    }
1284
0
}
1285
1286
0
std::optional<component::Fp2> ExecutorBignumCalc_Fp2::callModule(std::shared_ptr<Module> module, operation::BignumCalc_Fp2& op) const {
1287
0
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
1288
1289
    /* Prevent timeouts */
1290
0
    if ( op.bn0.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1291
0
    if ( op.bn0.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1292
0
    if ( op.bn1.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1293
0
    if ( op.bn1.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1294
0
    if ( op.bn2.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1295
0
    if ( op.bn2.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1296
0
    if ( op.bn3.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1297
0
    if ( op.bn3.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1298
1299
0
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
1300
0
        return std::nullopt;
1301
0
    }
1302
1303
0
    return module->OpBignumCalc_Fp2(op);
1304
0
}
1305
1306
/* Specialization for operation::BignumCalc_Fp12 */
1307
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 {
1308
0
    (void)module;
1309
0
    (void)op;
1310
1311
0
    if ( result.second != std::nullopt  ) {
1312
0
        Pool_Fp12.Set({
1313
0
                result.second->bn1.ToTrimmedString(),
1314
0
                result.second->bn2.ToTrimmedString(),
1315
0
                result.second->bn3.ToTrimmedString(),
1316
0
                result.second->bn4.ToTrimmedString(),
1317
0
                result.second->bn5.ToTrimmedString(),
1318
0
                result.second->bn6.ToTrimmedString(),
1319
0
                result.second->bn7.ToTrimmedString(),
1320
0
                result.second->bn8.ToTrimmedString(),
1321
0
                result.second->bn9.ToTrimmedString(),
1322
0
                result.second->bn10.ToTrimmedString(),
1323
0
                result.second->bn11.ToTrimmedString(),
1324
0
                result.second->bn12.ToTrimmedString()
1325
0
        });
1326
        /* TODO */
1327
#if 0
1328
        const auto bignum_first = result.second->first.ToTrimmedString();
1329
        const auto bignum_second = result.second->second.ToTrimmedString();
1330
1331
        if ( bignum_first.size() <= config::kMaxBignumSize ) {
1332
            Pool_Bignum.Set(bignum_first);
1333
        }
1334
        if ( bignum_second.size() <= config::kMaxBignumSize ) {
1335
            Pool_Bignum.Set(bignum_second);
1336
        }
1337
#endif
1338
0
    }
1339
0
}
1340
1341
0
std::optional<component::Fp12> ExecutorBignumCalc_Fp12::callModule(std::shared_ptr<Module> module, operation::BignumCalc_Fp12& op) const {
1342
0
    RETURN_IF_DISABLED(options.calcOps, op.calcOp.Get());
1343
1344
    /* Prevent timeouts */
1345
0
    if ( op.bn0.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1346
0
    if ( op.bn0.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1347
0
    if ( op.bn0.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1348
0
    if ( op.bn0.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1349
0
    if ( op.bn0.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1350
0
    if ( op.bn0.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1351
0
    if ( op.bn0.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1352
0
    if ( op.bn0.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1353
0
    if ( op.bn0.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1354
0
    if ( op.bn0.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1355
0
    if ( op.bn0.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1356
0
    if ( op.bn0.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1357
1358
0
    if ( op.bn1.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1359
0
    if ( op.bn1.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1360
0
    if ( op.bn1.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1361
0
    if ( op.bn1.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1362
0
    if ( op.bn1.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1363
0
    if ( op.bn1.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1364
0
    if ( op.bn1.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1365
0
    if ( op.bn1.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1366
0
    if ( op.bn1.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1367
0
    if ( op.bn1.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1368
0
    if ( op.bn1.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1369
0
    if ( op.bn1.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1370
1371
0
    if ( op.bn2.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1372
0
    if ( op.bn2.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1373
0
    if ( op.bn2.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1374
0
    if ( op.bn2.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1375
0
    if ( op.bn2.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1376
0
    if ( op.bn2.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1377
0
    if ( op.bn2.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1378
0
    if ( op.bn2.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1379
0
    if ( op.bn2.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1380
0
    if ( op.bn2.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1381
0
    if ( op.bn2.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1382
0
    if ( op.bn2.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1383
1384
0
    if ( op.bn3.bn1.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1385
0
    if ( op.bn3.bn2.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1386
0
    if ( op.bn3.bn3.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1387
0
    if ( op.bn3.bn4.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1388
0
    if ( op.bn3.bn5.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1389
0
    if ( op.bn3.bn6.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1390
0
    if ( op.bn3.bn7.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1391
0
    if ( op.bn3.bn8.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1392
0
    if ( op.bn3.bn9.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1393
0
    if ( op.bn3.bn10.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1394
0
    if ( op.bn3.bn11.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1395
0
    if ( op.bn3.bn12.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1396
1397
0
    if ( op.modulo != std::nullopt && !module->SupportsModularBignumCalc() ) {
1398
0
        return std::nullopt;
1399
0
    }
1400
1401
0
    return module->OpBignumCalc_Fp12(op);
1402
0
}
1403
1404
/* Specialization for operation::BLS_PrivateToPublic */
1405
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 {
1406
0
    (void)module;
1407
1408
0
    if ( result.second != std::nullopt  ) {
1409
0
        const auto curveID = op.curveType.Get();
1410
0
        const auto g1_x = result.second->first.ToTrimmedString();
1411
0
        const auto g1_y = result.second->second.ToTrimmedString();
1412
1413
0
        G1AddToPool(curveID, g1_x, g1_y);
1414
1415
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1416
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1417
0
    }
1418
0
}
1419
1420
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 {
1421
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1422
1423
0
    const size_t size = op.priv.ToTrimmedString().size();
1424
1425
0
    if ( size == 0 || size > 4096 ) {
1426
0
        return std::nullopt;
1427
0
    }
1428
1429
0
    return module->OpBLS_PrivateToPublic(op);
1430
0
}
1431
1432
/* Specialization for operation::BLS_PrivateToPublic_G2 */
1433
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 {
1434
0
    (void)module;
1435
0
    if ( result.second != std::nullopt  ) {
1436
0
        const auto curveID = op.curveType.Get();
1437
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1438
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1439
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1440
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1441
1442
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1443
1444
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1445
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1446
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1447
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1448
0
    }
1449
0
}
1450
1451
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 {
1452
0
    const size_t size = op.priv.ToTrimmedString().size();
1453
1454
0
    if ( size == 0 || size > 4096 ) {
1455
0
        return std::nullopt;
1456
0
    }
1457
1458
0
    return module->OpBLS_PrivateToPublic_G2(op);
1459
0
}
1460
1461
/* Specialization for operation::BLS_Sign */
1462
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 {
1463
0
    (void)module;
1464
1465
0
    if ( result.second != std::nullopt  ) {
1466
0
        const auto curveID = op.curveType.Get();
1467
0
        const auto point_v = op.hashOrPoint ? op.point.first.first.ToTrimmedString() : "";
1468
0
        const auto point_w = op.hashOrPoint ? op.point.first.second.ToTrimmedString() : "";
1469
0
        const auto point_x = op.hashOrPoint ? op.point.second.first.ToTrimmedString() : "";
1470
0
        const auto point_y = op.hashOrPoint ? op.point.second.second.ToTrimmedString() : "";
1471
0
        const auto cleartext = op.hashOrPoint ? op.cleartext.ToHex() : "";
1472
0
        const auto dest = op.dest.ToHex();
1473
0
        const auto aug = op.aug.ToHex();
1474
0
        const auto pub_x = result.second->pub.first.ToTrimmedString();
1475
0
        const auto pub_y = result.second->pub.second.ToTrimmedString();
1476
0
        const auto sig_v = result.second->signature.first.first.ToTrimmedString();
1477
0
        const auto sig_w = result.second->signature.first.second.ToTrimmedString();
1478
0
        const auto sig_x = result.second->signature.second.first.ToTrimmedString();
1479
0
        const auto sig_y = result.second->signature.second.second.ToTrimmedString();
1480
1481
0
        G1AddToPool(curveID, pub_x, pub_y);
1482
0
        G2AddToPool(curveID, sig_v, sig_w, sig_x, sig_y);
1483
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});
1484
1485
0
        if ( pub_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_x); }
1486
0
        if ( pub_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(pub_y); }
1487
0
        if ( sig_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_v); }
1488
0
        if ( sig_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_w); }
1489
0
        if ( sig_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_x); }
1490
0
        if ( sig_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(sig_y); }
1491
0
    }
1492
0
}
1493
1494
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 {
1495
0
    const size_t size = op.priv.ToTrimmedString().size();
1496
1497
0
    if ( size == 0 || size > 4096 ) {
1498
0
        return std::nullopt;
1499
0
    }
1500
1501
0
    return module->OpBLS_Sign(op);
1502
0
}
1503
1504
/* Specialization for operation::BLS_Verify */
1505
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 {
1506
0
    (void)module;
1507
0
    (void)op;
1508
0
    (void)result;
1509
0
}
1510
1511
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_Verify>::callModule(std::shared_ptr<Module> module, operation::BLS_Verify& op) const {
1512
#if 0
1513
    const std::vector<size_t> sizes = {
1514
        op.pub.first.ToTrimmedString().size(),
1515
        op.pub.second.ToTrimmedString().size(),
1516
        op.signature.first.ToTrimmedString().size(),
1517
        op.signature.second.ToTrimmedString().size(),
1518
    };
1519
1520
    for (const auto& size : sizes) {
1521
        if ( size == 0 || size > 4096 ) {
1522
            return std::nullopt;
1523
        }
1524
    }
1525
#endif
1526
1527
0
    return module->OpBLS_Verify(op);
1528
0
}
1529
1530
/* Specialization for operation::BLS_BatchSign */
1531
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 {
1532
0
    (void)module;
1533
0
    (void)op;
1534
1535
0
    if ( result.second != std::nullopt  ) {
1536
0
        std::vector< std::pair<BLS_BatchSignature_::G1, BLS_BatchSignature_::G2> > msgpub;
1537
0
        for (const auto& mp : result.second->msgpub) {
1538
0
            msgpub.push_back(
1539
0
                    std::pair<BLS_BatchSignature_::G1, BLS_BatchSignature_::G2>{
1540
0
                        {
1541
0
                            mp.first.first.ToTrimmedString(),
1542
0
                            mp.first.second.ToTrimmedString()
1543
0
                        },
1544
0
                        {
1545
0
                            mp.second.first.first.ToTrimmedString(),
1546
0
                            mp.second.first.second.ToTrimmedString(),
1547
0
                            mp.second.second.first.ToTrimmedString(),
1548
0
                            mp.second.second.second.ToTrimmedString()
1549
0
                        }
1550
0
                    }
1551
0
            );
1552
0
            G1AddToPool(CF_ECC_CURVE("BLS12_381"), mp.first.first.ToTrimmedString(), mp.first.second.ToTrimmedString());
1553
0
            Pool_CurveBLSG2.Set({
1554
0
                    CF_ECC_CURVE("BLS12_381"),
1555
0
                    mp.second.first.first.ToTrimmedString(),
1556
0
                    mp.second.first.second.ToTrimmedString(),
1557
0
                    mp.second.second.first.ToTrimmedString(),
1558
0
                    mp.second.second.second.ToTrimmedString()
1559
0
            });
1560
0
        }
1561
0
        Pool_BLS_BatchSignature.Set({msgpub});
1562
0
    }
1563
0
}
1564
1565
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 {
1566
0
    return module->OpBLS_BatchSign(op);
1567
0
}
1568
1569
/* Specialization for operation::BLS_BatchVerify */
1570
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 {
1571
0
    (void)module;
1572
0
    (void)op;
1573
0
    (void)result;
1574
0
}
1575
1576
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_BatchVerify>::callModule(std::shared_ptr<Module> module, operation::BLS_BatchVerify& op) const {
1577
0
    return module->OpBLS_BatchVerify(op);
1578
0
}
1579
1580
/* Specialization for operation::BLS_Aggregate_G1 */
1581
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 {
1582
0
    (void)module;
1583
0
    (void)op;
1584
0
    (void)result;
1585
0
}
1586
1587
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 {
1588
0
    return module->OpBLS_Aggregate_G1(op);
1589
0
}
1590
1591
/* Specialization for operation::BLS_Aggregate_G2 */
1592
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 {
1593
0
    (void)module;
1594
0
    (void)op;
1595
0
    (void)result;
1596
0
}
1597
1598
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 {
1599
0
    return module->OpBLS_Aggregate_G2(op);
1600
0
}
1601
1602
/* Specialization for operation::BLS_Pairing */
1603
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 {
1604
0
    (void)module;
1605
0
    (void)op;
1606
1607
0
    if ( result.second != std::nullopt  ) {
1608
0
        Pool_Fp12.Set({
1609
0
                result.second->bn1.ToTrimmedString(),
1610
0
                result.second->bn2.ToTrimmedString(),
1611
0
                result.second->bn3.ToTrimmedString(),
1612
0
                result.second->bn4.ToTrimmedString(),
1613
0
                result.second->bn5.ToTrimmedString(),
1614
0
                result.second->bn6.ToTrimmedString(),
1615
0
                result.second->bn7.ToTrimmedString(),
1616
0
                result.second->bn8.ToTrimmedString(),
1617
0
                result.second->bn9.ToTrimmedString(),
1618
0
                result.second->bn10.ToTrimmedString(),
1619
0
                result.second->bn11.ToTrimmedString(),
1620
0
                result.second->bn12.ToTrimmedString()
1621
0
        });
1622
0
    }
1623
0
}
1624
1625
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_Pairing>::callModule(std::shared_ptr<Module> module, operation::BLS_Pairing& op) const {
1626
0
    return module->OpBLS_Pairing(op);
1627
0
}
1628
1629
/* Specialization for operation::BLS_MillerLoop */
1630
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 {
1631
0
    (void)module;
1632
0
    (void)op;
1633
1634
0
    if ( result.second != std::nullopt  ) {
1635
0
        Pool_Fp12.Set({
1636
0
                result.second->bn1.ToTrimmedString(),
1637
0
                result.second->bn2.ToTrimmedString(),
1638
0
                result.second->bn3.ToTrimmedString(),
1639
0
                result.second->bn4.ToTrimmedString(),
1640
0
                result.second->bn5.ToTrimmedString(),
1641
0
                result.second->bn6.ToTrimmedString(),
1642
0
                result.second->bn7.ToTrimmedString(),
1643
0
                result.second->bn8.ToTrimmedString(),
1644
0
                result.second->bn9.ToTrimmedString(),
1645
0
                result.second->bn10.ToTrimmedString(),
1646
0
                result.second->bn11.ToTrimmedString(),
1647
0
                result.second->bn12.ToTrimmedString()
1648
0
        });
1649
0
    }
1650
0
}
1651
1652
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_MillerLoop>::callModule(std::shared_ptr<Module> module, operation::BLS_MillerLoop& op) const {
1653
0
    return module->OpBLS_MillerLoop(op);
1654
0
}
1655
1656
/* Specialization for operation::BLS_FinalExp */
1657
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 {
1658
0
    (void)module;
1659
0
    (void)op;
1660
1661
0
    if ( result.second != std::nullopt  ) {
1662
0
        Pool_Fp12.Set({
1663
0
                result.second->bn1.ToTrimmedString(),
1664
0
                result.second->bn2.ToTrimmedString(),
1665
0
                result.second->bn3.ToTrimmedString(),
1666
0
                result.second->bn4.ToTrimmedString(),
1667
0
                result.second->bn5.ToTrimmedString(),
1668
0
                result.second->bn6.ToTrimmedString(),
1669
0
                result.second->bn7.ToTrimmedString(),
1670
0
                result.second->bn8.ToTrimmedString(),
1671
0
                result.second->bn9.ToTrimmedString(),
1672
0
                result.second->bn10.ToTrimmedString(),
1673
0
                result.second->bn11.ToTrimmedString(),
1674
0
                result.second->bn12.ToTrimmedString()
1675
0
        });
1676
0
    }
1677
0
}
1678
1679
0
template<> std::optional<component::Fp12> ExecutorBase<component::Fp12, operation::BLS_FinalExp>::callModule(std::shared_ptr<Module> module, operation::BLS_FinalExp& op) const {
1680
0
    return module->OpBLS_FinalExp(op);
1681
0
}
1682
1683
/* Specialization for operation::BLS_HashToG1 */
1684
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 {
1685
0
    (void)module;
1686
1687
0
    if ( result.second != std::nullopt  ) {
1688
0
        const auto curveID = op.curveType.Get();
1689
0
        const auto g1_x = result.second->first.ToTrimmedString();
1690
0
        const auto g1_y = result.second->second.ToTrimmedString();
1691
1692
0
        G1AddToPool(curveID, g1_x, g1_y);
1693
1694
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1695
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1696
0
    }
1697
0
}
1698
1699
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_HashToG1>::callModule(std::shared_ptr<Module> module, operation::BLS_HashToG1& op) const {
1700
0
    return module->OpBLS_HashToG1(op);
1701
0
}
1702
1703
/* Specialization for operation::BLS_MapToG1 */
1704
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 {
1705
0
    (void)module;
1706
1707
0
    if ( result.second != std::nullopt  ) {
1708
0
        const auto curveID = op.curveType.Get();
1709
0
        const auto g1_x = result.second->first.ToTrimmedString();
1710
0
        const auto g1_y = result.second->second.ToTrimmedString();
1711
1712
0
        G1AddToPool(curveID, g1_x, g1_y);
1713
1714
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1715
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1716
0
    }
1717
0
}
1718
1719
0
template<> std::optional<component::G1> ExecutorBase<component::G1, operation::BLS_MapToG1>::callModule(std::shared_ptr<Module> module, operation::BLS_MapToG1& op) const {
1720
0
    return module->OpBLS_MapToG1(op);
1721
0
}
1722
1723
/* Specialization for operation::BLS_MapToG2 */
1724
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 {
1725
0
    (void)module;
1726
1727
0
    if ( result.second != std::nullopt  ) {
1728
0
        const auto curveID = op.curveType.Get();
1729
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1730
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1731
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1732
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1733
1734
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1735
1736
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1737
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1738
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1739
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1740
0
    }
1741
0
}
1742
1743
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_MapToG2>::callModule(std::shared_ptr<Module> module, operation::BLS_MapToG2& op) const {
1744
0
    return module->OpBLS_MapToG2(op);
1745
0
}
1746
1747
/* Specialization for operation::BLS_IsG1OnCurve */
1748
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 {
1749
0
    (void)module;
1750
0
    (void)op;
1751
0
    (void)result;
1752
0
}
1753
1754
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_IsG1OnCurve>::callModule(std::shared_ptr<Module> module, operation::BLS_IsG1OnCurve& op) const {
1755
0
    if ( op.g1.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1756
0
    if ( op.g1.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1757
1758
0
    return module->OpBLS_IsG1OnCurve(op);
1759
0
}
1760
1761
/* Specialization for operation::BLS_IsG2OnCurve */
1762
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 {
1763
0
    (void)module;
1764
0
    (void)op;
1765
0
    (void)result;
1766
0
}
1767
1768
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_IsG2OnCurve>::callModule(std::shared_ptr<Module> module, operation::BLS_IsG2OnCurve& op) const {
1769
0
    if ( op.g2.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1770
0
    if ( op.g2.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1771
0
    if ( op.g2.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1772
0
    if ( op.g2.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1773
1774
0
    return module->OpBLS_IsG2OnCurve(op);
1775
0
}
1776
1777
/* Specialization for operation::BLS_GenerateKeyPair */
1778
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 {
1779
0
    (void)module;
1780
1781
0
    if ( result.second != std::nullopt  ) {
1782
0
        const auto curveID = op.curveType.Get();
1783
0
        const auto priv = result.second->priv.ToTrimmedString();
1784
0
        const auto g1_x = result.second->pub.first.ToTrimmedString();
1785
0
        const auto g1_y = result.second->pub.second.ToTrimmedString();
1786
1787
0
        G1AddToPool(curveID, g1_x, g1_y);
1788
1789
0
        if ( priv.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(priv); }
1790
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1791
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1792
0
    }
1793
0
}
1794
1795
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 {
1796
0
    return module->OpBLS_GenerateKeyPair(op);
1797
0
}
1798
1799
/* Specialization for operation::BLS_Decompress_G1 */
1800
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 {
1801
0
    (void)module;
1802
1803
0
    if ( result.second != std::nullopt  ) {
1804
0
        const auto curveID = op.curveType.Get();
1805
0
        const auto g1_x = result.second->first.ToTrimmedString();
1806
0
        const auto g1_y = result.second->second.ToTrimmedString();
1807
1808
0
        G1AddToPool(curveID, g1_x, g1_y);
1809
1810
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1811
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1812
0
    }
1813
0
}
1814
1815
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 {
1816
0
    return module->OpBLS_Decompress_G1(op);
1817
0
}
1818
1819
/* Specialization for operation::BLS_Compress_G1 */
1820
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 {
1821
0
    (void)module;
1822
1823
0
    if ( result.second != std::nullopt  ) {
1824
0
        const auto compressed = result.second->ToTrimmedString();
1825
1826
0
        if ( compressed.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(compressed); }
1827
0
    }
1828
0
}
1829
1830
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 {
1831
0
    return module->OpBLS_Compress_G1(op);
1832
0
}
1833
1834
/* Specialization for operation::BLS_Decompress_G2 */
1835
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 {
1836
0
    (void)module;
1837
1838
0
    if ( result.second != std::nullopt  ) {
1839
0
        const auto curveID = op.curveType.Get();
1840
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1841
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1842
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1843
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1844
1845
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1846
1847
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1848
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1849
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1850
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1851
0
    }
1852
0
}
1853
1854
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 {
1855
0
    return module->OpBLS_Decompress_G2(op);
1856
0
}
1857
1858
/* Specialization for operation::BLS_Compress_G2 */
1859
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 {
1860
0
    (void)module;
1861
1862
0
    if ( result.second != std::nullopt  ) {
1863
0
        const auto curveID = op.curveType.Get();
1864
0
        const auto g1_x = result.second->first.ToTrimmedString();
1865
0
        const auto g1_y = result.second->second.ToTrimmedString();
1866
1867
0
        G1AddToPool(curveID, g1_x, g1_y);
1868
1869
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1870
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1871
0
    }
1872
0
}
1873
1874
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 {
1875
0
    return module->OpBLS_Compress_G2(op);
1876
0
}
1877
1878
/* Specialization for operation::BLS_G1_Add */
1879
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 {
1880
0
    (void)module;
1881
1882
0
    if ( result.second != std::nullopt  ) {
1883
0
        const auto curveID = op.curveType.Get();
1884
0
        const auto g1_x = result.second->first.ToTrimmedString();
1885
0
        const auto g1_y = result.second->second.ToTrimmedString();
1886
1887
0
        G1AddToPool(curveID, g1_x, g1_y);
1888
1889
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1890
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1891
0
    }
1892
0
}
1893
1894
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 {
1895
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1896
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1897
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1898
0
    if ( op.b.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1899
0
    if ( op.b.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1900
1901
0
    return module->OpBLS_G1_Add(op);
1902
0
}
1903
1904
/* Specialization for operation::BLS_G1_Mul */
1905
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 {
1906
0
    (void)module;
1907
1908
0
    if ( result.second != std::nullopt  ) {
1909
0
        const auto curveID = op.curveType.Get();
1910
0
        const auto g1_x = result.second->first.ToTrimmedString();
1911
0
        const auto g1_y = result.second->second.ToTrimmedString();
1912
1913
0
        G1AddToPool(curveID, g1_x, g1_y);
1914
1915
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1916
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1917
0
    }
1918
0
}
1919
1920
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 {
1921
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1922
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1923
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1924
0
    if ( op.b.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1925
1926
0
    return module->OpBLS_G1_Mul(op);
1927
0
}
1928
1929
/* Specialization for operation::BLS_G1_IsEq */
1930
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 {
1931
0
    (void)module;
1932
0
    (void)op;
1933
0
    (void)result;
1934
0
}
1935
1936
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_G1_IsEq>::callModule(std::shared_ptr<Module> module, operation::BLS_G1_IsEq& op) const {
1937
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1938
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1939
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1940
0
    if ( op.b.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1941
0
    if ( op.b.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1942
1943
0
    return module->OpBLS_G1_IsEq(op);
1944
0
}
1945
1946
/* Specialization for operation::BLS_G1_Neg */
1947
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 {
1948
0
    (void)module;
1949
1950
0
    if ( result.second != std::nullopt  ) {
1951
0
        const auto curveID = op.curveType.Get();
1952
0
        const auto g1_x = result.second->first.ToTrimmedString();
1953
0
        const auto g1_y = result.second->second.ToTrimmedString();
1954
1955
0
        G1AddToPool(curveID, g1_x, g1_y);
1956
1957
0
        if ( g1_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_x); }
1958
0
        if ( g1_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g1_y); }
1959
0
    }
1960
0
}
1961
1962
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 {
1963
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1964
0
    if ( op.a.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1965
0
    if ( op.a.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1966
1967
0
    return module->OpBLS_G1_Neg(op);
1968
0
}
1969
1970
/* Specialization for operation::BLS_G2_Add */
1971
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 {
1972
0
    (void)module;
1973
1974
0
    if ( result.second != std::nullopt  ) {
1975
0
        const auto curveID = op.curveType.Get();
1976
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
1977
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
1978
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
1979
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
1980
1981
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
1982
1983
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
1984
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
1985
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
1986
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
1987
0
    }
1988
0
}
1989
1990
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 {
1991
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
1992
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1993
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1994
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1995
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1996
0
    if ( op.b.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1997
0
    if ( op.b.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1998
0
    if ( op.b.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
1999
0
    if ( op.b.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2000
2001
0
    return module->OpBLS_G2_Add(op);
2002
0
}
2003
2004
/* Specialization for operation::BLS_G2_Mul */
2005
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 {
2006
0
    (void)module;
2007
2008
0
    if ( result.second != std::nullopt  ) {
2009
0
        const auto curveID = op.curveType.Get();
2010
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
2011
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
2012
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
2013
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
2014
2015
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
2016
2017
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
2018
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
2019
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
2020
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
2021
0
    }
2022
0
}
2023
2024
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 {
2025
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
2026
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2027
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2028
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2029
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2030
0
    if ( op.b.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2031
2032
0
    return module->OpBLS_G2_Mul(op);
2033
0
}
2034
2035
/* Specialization for operation::BLS_G2_IsEq */
2036
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 {
2037
0
    (void)module;
2038
0
    (void)op;
2039
0
    (void)result;
2040
0
}
2041
2042
0
template<> std::optional<bool> ExecutorBase<bool, operation::BLS_G2_IsEq>::callModule(std::shared_ptr<Module> module, operation::BLS_G2_IsEq& op) const {
2043
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
2044
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2045
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2046
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2047
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2048
0
    if ( op.b.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2049
0
    if ( op.b.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2050
0
    if ( op.b.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2051
0
    if ( op.b.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2052
2053
0
    return module->OpBLS_G2_IsEq(op);
2054
0
}
2055
2056
/* Specialization for operation::BLS_G2_Neg */
2057
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 {
2058
0
    (void)module;
2059
2060
0
    if ( result.second != std::nullopt  ) {
2061
0
        const auto curveID = op.curveType.Get();
2062
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
2063
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
2064
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
2065
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
2066
2067
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
2068
2069
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
2070
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
2071
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
2072
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
2073
0
    }
2074
0
}
2075
2076
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 {
2077
0
    RETURN_IF_DISABLED(options.curves, op.curveType.Get());
2078
0
    if ( op.a.first.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2079
0
    if ( op.a.first.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2080
0
    if ( op.a.second.first.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2081
0
    if ( op.a.second.second.GetSize() > config::kMaxBignumSize ) return std::nullopt;
2082
2083
0
    return module->OpBLS_G2_Neg(op);
2084
0
}
2085
2086
/* Specialization for operation::Misc */
2087
0
template<> void ExecutorBase<Buffer, operation::Misc>::postprocess(std::shared_ptr<Module> module, operation::Misc& op, const ExecutorBase<Buffer, operation::Misc>::ResultPair& result) const {
2088
0
    (void)module;
2089
0
    (void)op;
2090
0
    (void)result;
2091
0
}
2092
2093
0
template<> std::optional<Buffer> ExecutorBase<Buffer, operation::Misc>::callModule(std::shared_ptr<Module> module, operation::Misc& op) const {
2094
0
    return module->OpMisc(op);
2095
0
}
2096
2097
/* Specialization for operation::BLS_HashToG2 */
2098
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 {
2099
0
    (void)module;
2100
2101
0
    if ( result.second != std::nullopt  ) {
2102
0
        const auto curveID = op.curveType.Get();
2103
0
        const auto g2_v = result.second->first.first.ToTrimmedString();
2104
0
        const auto g2_w = result.second->first.second.ToTrimmedString();
2105
0
        const auto g2_x = result.second->second.first.ToTrimmedString();
2106
0
        const auto g2_y = result.second->second.second.ToTrimmedString();
2107
2108
0
        G2AddToPool(curveID, g2_v, g2_w, g2_x, g2_y);
2109
2110
0
        if ( g2_v.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_v); }
2111
0
        if ( g2_w.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_w); }
2112
0
        if ( g2_x.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_x); }
2113
0
        if ( g2_y.size() <= config::kMaxBignumSize ) { Pool_Bignum.Set(g2_y); }
2114
0
    }
2115
0
}
2116
2117
0
template<> std::optional<component::G2> ExecutorBase<component::G2, operation::BLS_HashToG2>::callModule(std::shared_ptr<Module> module, operation::BLS_HashToG2& op) const {
2118
0
    return module->OpBLS_HashToG2(op);
2119
0
}
2120
2121
ExecutorBignumCalc::ExecutorBignumCalc(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2122
    ExecutorBase<component::Bignum, operation::BignumCalc>::ExecutorBase(operationID, modules, options)
2123
20
{ }
2124
19
void ExecutorBignumCalc::SetModulo(const std::string& modulo) {
2125
19
    this->modulo = component::Bignum(modulo);
2126
19
}
2127
2128
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) :
2129
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2130
1
    CF_NORET(SetModulo("52435875175126190479447740508185965837690552500527637822603658699938581184513"));
2131
1
}
2132
2133
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) :
2134
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2135
1
    CF_NORET(SetModulo("4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"));
2136
1
}
2137
2138
ExecutorBignumCalc_Mod_BLS12_377_R::ExecutorBignumCalc_Mod_BLS12_377_R(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2139
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2140
1
    CF_NORET(SetModulo("8444461749428370424248824938781546531375899335154063827935233455917409239041"));
2141
1
}
2142
2143
ExecutorBignumCalc_Mod_BLS12_377_P::ExecutorBignumCalc_Mod_BLS12_377_P(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2144
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2145
1
    CF_NORET(SetModulo("258664426012969094010652733694893533536393512754914660539884262666720468348340822774968888139573360124440321458177"));
2146
1
}
2147
2148
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) :
2149
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2150
1
    CF_NORET(SetModulo("21888242871839275222246405745257275088548364400416034343698204186575808495617"));
2151
1
}
2152
2153
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) :
2154
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2155
1
    CF_NORET(SetModulo("21888242871839275222246405745257275088696311157297823662689037894645226208583"));
2156
1
}
2157
2158
ExecutorBignumCalc_Mod_ED25519::ExecutorBignumCalc_Mod_ED25519(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2159
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2160
1
    CF_NORET(SetModulo("57896044618658097711785492504343953926634992332820282019728792003956564819949"));
2161
1
}
2162
2163
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) :
2164
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2165
1
    CF_NORET(SetModulo("1552511030102430251236801561344621993261920897571225601"));
2166
1
}
2167
2168
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) :
2169
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2170
1
    CF_NORET(SetModulo("6210044120409721004947206240885978274523751269793792001"));
2171
1
}
2172
2173
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) :
2174
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2175
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963137"));
2176
1
}
2177
2178
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) :
2179
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2180
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081"));
2181
1
}
2182
2183
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) :
2184
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2185
1
    CF_NORET(SetModulo("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081"));
2186
1
}
2187
2188
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) :
2189
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2190
1
    CF_NORET(SetModulo("237961143084630662876674624826524225772562439621347362697777564288105131408977900241879040"));
2191
1
}
2192
2193
ExecutorBignumCalc_Mod_2Exp64::ExecutorBignumCalc_Mod_2Exp64(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2194
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2195
1
    CF_NORET(SetModulo("18446744073709551616"));
2196
1
}
2197
2198
ExecutorBignumCalc_Mod_2Exp128::ExecutorBignumCalc_Mod_2Exp128(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2199
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2200
1
    CF_NORET(SetModulo("340282366920938463463374607431768211456"));
2201
1
}
2202
2203
ExecutorBignumCalc_Mod_2Exp256::ExecutorBignumCalc_Mod_2Exp256(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2204
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2205
1
    CF_NORET(SetModulo("115792089237316195423570985008687907853269984665640564039457584007913129639936"));
2206
1
}
2207
2208
ExecutorBignumCalc_Mod_2Exp512::ExecutorBignumCalc_Mod_2Exp512(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2209
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2210
1
    CF_NORET(SetModulo("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"));
2211
1
}
2212
2213
ExecutorBignumCalc_Mod_SECP256K1::ExecutorBignumCalc_Mod_SECP256K1(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2214
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2215
1
    CF_NORET(SetModulo("115792089237316195423570985008687907852837564279074904382605163141518161494337"));
2216
1
}
2217
2218
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) :
2219
1
    ExecutorBignumCalc::ExecutorBignumCalc(operationID, modules, options) {
2220
1
    CF_NORET(SetModulo("115792089237316195423570985008687907853269984665640564039457584007908834671663"));
2221
1
}
2222
2223
ExecutorBignumCalc_Fp2::ExecutorBignumCalc_Fp2(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2224
    ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>::ExecutorBase(operationID, modules, options)
2225
1
{ }
2226
0
void ExecutorBignumCalc_Fp2::SetModulo(const std::string& modulo) {
2227
0
    this->modulo = component::Bignum(modulo);
2228
0
}
2229
2230
ExecutorBignumCalc_Fp12::ExecutorBignumCalc_Fp12(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2231
    ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>::ExecutorBase(operationID, modules, options)
2232
1
{ }
2233
0
void ExecutorBignumCalc_Fp12::SetModulo(const std::string& modulo) {
2234
0
    this->modulo = component::Bignum(modulo);
2235
0
}
2236
2237
template <class ResultType, class OperationType>
2238
ExecutorBase<ResultType, OperationType>::ExecutorBase(const uint64_t operationID, const std::map<uint64_t, std::shared_ptr<Module> >& modules, const Options& options) :
2239
    operationID(operationID),
2240
    modules(modules),
2241
    options(options)
2242
100
{
2243
100
}
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
20
{
2243
20
}
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
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
2242
1
{
2243
1
}
2244
2245
/* Specialization for operation::SR25519_Verify */
2246
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 {
2247
0
    (void)module;
2248
0
    (void)op;
2249
0
    (void)result;
2250
0
}
2251
2252
0
template<> std::optional<bool> ExecutorBase<bool, operation::SR25519_Verify>::callModule(std::shared_ptr<Module> module, operation::SR25519_Verify& op) const {
2253
0
    return module->OpSR25519_Verify(op);
2254
0
}
2255
2256
template <class ResultType, class OperationType>
2257
100
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
100
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::UMAC>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::CMAC>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::SymmetricEncrypt>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::SymmetricDecrypt>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SCRYPT>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_HKDF>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_TLS1_PRF>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_PBKDF2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_ARGON2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SSH>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_X963>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_BCRYPT>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::KDF_SP_800_108>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_PrivateToPublic>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::Schnorr_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECDSA_Recover>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::~ExecutorBase()
Line
Count
Source
2257
20
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
20
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BignumCalc_Fp2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BignumCalc_Fp12>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_PrivateToPublic>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_PrivateToPublic_G2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_Signature, cryptofuzz::operation::BLS_Sign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_BatchSignature, cryptofuzz::operation::BLS_BatchSign>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_BatchVerify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Aggregate_G1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Aggregate_G2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_Pairing>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_MillerLoop>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::Fp12, cryptofuzz::operation::BLS_FinalExp>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_HashToG1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_HashToG2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_MapToG1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_MapToG2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG1OnCurve>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_IsG2OnCurve>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BLS_KeyPair, cryptofuzz::operation::BLS_GenerateKeyPair>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Decompress_G1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BLS_Compress_G1>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_Decompress_G2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_Compress_G2>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Add>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Mul>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G1_IsEq>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::BLS_G1_Neg>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Add>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Mul>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::BLS_G2_IsEq>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::component::G2, cryptofuzz::operation::BLS_G2_Neg>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Misc>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::SR25519_Verify>::~ExecutorBase()
Line
Count
Source
2257
1
ExecutorBase<ResultType, OperationType>::~ExecutorBase() {
2258
1
}
2259
2260
/* Filter away the values in the set that are std::nullopt */
2261
template <class ResultType, class OperationType>
2262
7.97k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
7.97k
    ResultSet ret;
2264
2265
34.0k
    for (const auto& result : results) {
2266
34.0k
        if ( result.second == std::nullopt ) {
2267
15.9k
            continue;
2268
15.9k
        }
2269
2270
18.1k
        ret.push_back(result);
2271
18.1k
    }
2272
2273
7.97k
    return ret;
2274
7.97k
}
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
Line
Count
Source
2262
464
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
464
    ResultSet ret;
2264
2265
2.17k
    for (const auto& result : results) {
2266
2.17k
        if ( result.second == std::nullopt ) {
2267
829
            continue;
2268
829
        }
2269
2270
1.34k
        ret.push_back(result);
2271
1.34k
    }
2272
2273
464
    return ret;
2274
464
}
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
Line
Count
Source
2262
367
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
367
    ResultSet ret;
2264
2265
1.79k
    for (const auto& result : results) {
2266
1.79k
        if ( result.second == std::nullopt ) {
2267
1.07k
            continue;
2268
1.07k
        }
2269
2270
722
        ret.push_back(result);
2271
722
    }
2272
2273
367
    return ret;
2274
367
}
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
2262
506
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
506
    ResultSet ret;
2264
2265
2.08k
    for (const auto& result : results) {
2266
2.08k
        if ( result.second == std::nullopt ) {
2267
880
            continue;
2268
880
        }
2269
2270
1.20k
        ret.push_back(result);
2271
1.20k
    }
2272
2273
506
    return ret;
2274
506
}
Unexecuted instantiation: 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
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECCSI_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECCSI_Signature> > > > 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
2262
620
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
620
    ResultSet ret;
2264
2265
2.69k
    for (const auto& result : results) {
2266
2.69k
        if ( result.second == std::nullopt ) {
2267
1.80k
            continue;
2268
1.80k
        }
2269
2270
895
        ret.push_back(result);
2271
895
    }
2272
2273
620
    return ret;
2274
620
}
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
Line
Count
Source
2262
139
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
139
    ResultSet ret;
2264
2265
681
    for (const auto& result : results) {
2266
681
        if ( result.second == std::nullopt ) {
2267
490
            continue;
2268
490
        }
2269
2270
191
        ret.push_back(result);
2271
191
    }
2272
2273
139
    return ret;
2274
139
}
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
Line
Count
Source
2262
102
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
102
    ResultSet ret;
2264
2265
513
    for (const auto& result : results) {
2266
513
        if ( result.second == std::nullopt ) {
2267
405
            continue;
2268
405
        }
2269
2270
108
        ret.push_back(result);
2271
108
    }
2272
2273
102
    return ret;
2274
102
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_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
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
2262
272
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
272
    ResultSet ret;
2264
2265
1.18k
    for (const auto& result : results) {
2266
1.18k
        if ( result.second == std::nullopt ) {
2267
738
            continue;
2268
738
        }
2269
2270
442
        ret.push_back(result);
2271
442
    }
2272
2273
272
    return ret;
2274
272
}
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
Line
Count
Source
2262
123
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
123
    ResultSet ret;
2264
2265
595
    for (const auto& result : results) {
2266
595
        if ( result.second == std::nullopt ) {
2267
397
            continue;
2268
397
        }
2269
2270
198
        ret.push_back(result);
2271
198
    }
2272
2273
123
    return ret;
2274
123
}
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
Line
Count
Source
2262
88
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
88
    ResultSet ret;
2264
2265
436
    for (const auto& result : results) {
2266
436
        if ( result.second == std::nullopt ) {
2267
375
            continue;
2268
375
        }
2269
2270
61
        ret.push_back(result);
2271
61
    }
2272
2273
88
    return ret;
2274
88
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_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::DSA_Signature, cryptofuzz::operation::DSA_Sign>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::DSA_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::DSA_Signature> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::filter(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::DSA_Parameters> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::DSA_Parameters> > > > const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::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::BignumPair, cryptofuzz::operation::DSA_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::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
2262
75
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
75
    ResultSet ret;
2264
2265
351
    for (const auto& result : results) {
2266
351
        if ( result.second == std::nullopt ) {
2267
322
            continue;
2268
322
        }
2269
2270
29
        ret.push_back(result);
2271
29
    }
2272
2273
75
    return ret;
2274
75
}
Unexecuted instantiation: 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
Unexecuted instantiation: 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
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
2262
122
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
122
    ResultSet ret;
2264
2265
555
    for (const auto& result : results) {
2266
555
        if ( result.second == std::nullopt ) {
2267
535
            continue;
2268
535
        }
2269
2270
20
        ret.push_back(result);
2271
20
    }
2272
2273
122
    return ret;
2274
122
}
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
2262
314
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
314
    ResultSet ret;
2264
2265
1.30k
    for (const auto& result : results) {
2266
1.30k
        if ( result.second == std::nullopt ) {
2267
1.12k
            continue;
2268
1.12k
        }
2269
2270
187
        ret.push_back(result);
2271
187
    }
2272
2273
314
    return ret;
2274
314
}
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
Line
Count
Source
2262
86
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
86
    ResultSet ret;
2264
2265
384
    for (const auto& result : results) {
2266
384
        if ( result.second == std::nullopt ) {
2267
355
            continue;
2268
355
        }
2269
2270
29
        ret.push_back(result);
2271
29
    }
2272
2273
86
    return ret;
2274
86
}
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
Line
Count
Source
2262
267
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
267
    ResultSet ret;
2264
2265
1.14k
    for (const auto& result : results) {
2266
1.14k
        if ( result.second == std::nullopt ) {
2267
1.07k
            continue;
2268
1.07k
        }
2269
2270
72
        ret.push_back(result);
2271
72
    }
2272
2273
267
    return ret;
2274
267
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::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::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
Unexecuted instantiation: 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
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
2262
4.43k
typename ExecutorBase<ResultType, OperationType>::ResultSet ExecutorBase<ResultType, OperationType>::filter(const ResultSet& results) const {
2263
4.43k
    ResultSet ret;
2264
2265
18.1k
    for (const auto& result : results) {
2266
18.1k
        if ( result.second == std::nullopt ) {
2267
5.53k
            continue;
2268
5.53k
        }
2269
2270
12.5k
        ret.push_back(result);
2271
12.5k
    }
2272
2273
4.43k
    return ret;
2274
4.43k
}
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
2275
2276
/* Do not compare ECC_GenerateKeyPair results, because the result can be produced indeterministically */
2277
template <>
2278
0
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 {
2279
0
    (void)operations;
2280
0
    (void)results;
2281
0
    (void)data;
2282
0
    (void)size;
2283
0
}
2284
2285
template <class ResultType, class OperationType>
2286
1.17k
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
1.17k
    (void)operation;
2288
2289
1.17k
    return false;
2290
1.17k
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::dontCompare(cryptofuzz::operation::Digest const&) const
Line
Count
Source
2286
441
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
441
    (void)operation;
2288
2289
441
    return false;
2290
441
}
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
2286
421
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
421
    (void)operation;
2288
2289
421
    return false;
2290
421
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::dontCompare(cryptofuzz::operation::ECC_ValidatePubkey const&) const
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::dontCompare(cryptofuzz::operation::ECCSI_Verify const&) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::dontCompare(cryptofuzz::operation::ECDSA_Verify const&) const
Line
Count
Source
2286
131
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
131
    (void)operation;
2288
2289
131
    return false;
2290
131
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::dontCompare(cryptofuzz::operation::ECGDSA_Verify const&) const
Line
Count
Source
2286
48
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
48
    (void)operation;
2288
2289
48
    return false;
2290
48
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::dontCompare(cryptofuzz::operation::ECRDSA_Verify const&) const
Line
Count
Source
2286
13
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
13
    (void)operation;
2288
2289
13
    return false;
2290
13
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::dontCompare(cryptofuzz::operation::DSA_Verify const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::dontCompare(cryptofuzz::operation::DSA_Sign const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::dontCompare(cryptofuzz::operation::DSA_GenerateParameters const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::dontCompare(cryptofuzz::operation::DSA_PrivateToPublic const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::dontCompare(cryptofuzz::operation::DSA_GenerateKeyPair const&) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::dontCompare(cryptofuzz::operation::ECDH_Derive const&) const
Line
Count
Source
2286
9
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
9
    (void)operation;
2288
2289
9
    return false;
2290
9
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::dontCompare(cryptofuzz::operation::ECIES_Encrypt const&) const
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
2286
7
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
7
    (void)operation;
2288
2289
7
    return false;
2290
7
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::dontCompare(cryptofuzz::operation::ECC_Point_Mul const&) const
Line
Count
Source
2286
64
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
64
    (void)operation;
2288
2289
64
    return false;
2290
64
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::dontCompare(cryptofuzz::operation::ECC_Point_Neg const&) const
Line
Count
Source
2286
11
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
11
    (void)operation;
2288
2289
11
    return false;
2290
11
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::dontCompare(cryptofuzz::operation::ECC_Point_Dbl const&) const
Line
Count
Source
2286
27
bool ExecutorBase<ResultType, OperationType>::dontCompare(const OperationType& operation) const {
2287
27
    (void)operation;
2288
2289
27
    return false;
2290
27
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::dontCompare(cryptofuzz::operation::ECC_Point_Cmp const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::dontCompare(cryptofuzz::operation::DH_GenerateKeyPair const&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::dontCompare(cryptofuzz::operation::DH_Derive const&) const
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
2291
2292
template <>
2293
4.09k
bool ExecutorBase<component::Bignum, operation::BignumCalc>::dontCompare(const operation::BignumCalc& operation) const {
2294
4.09k
    if ( operation.calcOp.Get() == CF_CALCOP("Rand()") ) { return true; }
2295
4.09k
    if ( operation.calcOp.Get() == CF_CALCOP("Prime()") ) { return true; }
2296
2297
4.09k
    return false;
2298
4.09k
}
2299
2300
template <>
2301
0
bool ExecutorBase<component::ECCSI_Signature, operation::ECCSI_Sign>::dontCompare(const operation::ECCSI_Sign& operation) const {
2302
0
    return true;
2303
0
}
2304
2305
template <>
2306
258
bool ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>::dontCompare(const operation::ECDSA_Sign& operation) const {
2307
258
    if (
2308
258
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
2309
258
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
2310
218
        if ( operation.UseRandomNonce() ) {
2311
            /* Don't compare ECDSA signatures comptued from a randomly generated nonce */
2312
196
            return true;
2313
196
        }
2314
218
    }
2315
2316
62
    return false;
2317
258
}
2318
2319
template <>
2320
63
bool ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>::dontCompare(const operation::ECGDSA_Sign& operation) const {
2321
63
    if (
2322
63
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
2323
63
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
2324
63
        if ( operation.UseRandomNonce() ) {
2325
            /* Don't compare ECGDSA signatures comptued from a randomly generated nonce */
2326
55
            return true;
2327
55
        }
2328
63
    }
2329
2330
8
    return false;
2331
63
}
2332
2333
template <>
2334
25
bool ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>::dontCompare(const operation::ECRDSA_Sign& operation) const {
2335
25
    if (
2336
25
            operation.curveType.Get() != CF_ECC_CURVE("ed25519") &&
2337
25
            operation.curveType.Get() != CF_ECC_CURVE("ed448") ) {
2338
25
        if ( operation.UseRandomNonce() ) {
2339
            /* Don't compare ECRDSA signatures comptued from a randomly generated nonce */
2340
20
            return true;
2341
20
        }
2342
25
    }
2343
2344
5
    return false;
2345
25
}
2346
2347
/* OpenSSL DES_EDE3_WRAP randomizes the IV, result is different each time */
2348
template <>
2349
0
bool ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>::dontCompare(const operation::SymmetricEncrypt& operation) const {
2350
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) { return true; }
2351
2352
0
    return false;
2353
0
}
2354
2355
template <>
2356
0
bool ExecutorBase<component::Cleartext, operation::SymmetricDecrypt>::dontCompare(const operation::SymmetricDecrypt& operation) const {
2357
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2358
2359
0
    return false;
2360
0
}
2361
2362
template <>
2363
0
bool ExecutorBase<component::MAC, operation::CMAC>::dontCompare(const operation::CMAC& operation) const {
2364
0
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2365
2366
0
    return false;
2367
0
}
2368
2369
template <>
2370
270
bool ExecutorBase<component::MAC, operation::HMAC>::dontCompare(const operation::HMAC& operation) const {
2371
270
    if ( operation.cipher.cipherType.Get() == CF_CIPHER("DES_EDE3_WRAP") ) return true;
2372
2373
268
    return false;
2374
270
}
2375
2376
template <class ResultType, class OperationType>
2377
7.97k
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 {
2378
7.97k
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
7.97k
    const auto filtered = filter(results);
2384
2385
7.97k
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
2.09k
        return;
2388
2.09k
    }
2389
2390
5.88k
    if ( dontCompare(operations[0].second) == true ) {
2391
273
        return;
2392
273
    }
2393
2394
16.4k
    for (size_t i = 1; i < filtered.size(); i++) {
2395
10.8k
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
10.8k
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
10.8k
        const bool equal = *prev == *cur;
2399
2400
10.8k
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
10.8k
    }
2417
5.61k
}
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
Line
Count
Source
2377
464
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 {
2378
464
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
464
    const auto filtered = filter(results);
2384
2385
464
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
23
        return;
2388
23
    }
2389
2390
441
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
1.33k
    for (size_t i = 1; i < filtered.size(); i++) {
2395
889
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
889
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
889
        const bool equal = *prev == *cur;
2399
2400
889
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
889
    }
2417
441
}
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
Line
Count
Source
2377
367
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 {
2378
367
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
367
    const auto filtered = filter(results);
2384
2385
367
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
97
        return;
2388
97
    }
2389
2390
270
    if ( dontCompare(operations[0].second) == true ) {
2391
2
        return;
2392
2
    }
2393
2394
641
    for (size_t i = 1; i < filtered.size(); i++) {
2395
373
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
373
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
373
        const bool equal = *prev == *cur;
2399
2400
373
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
373
    }
2417
268
}
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
2377
506
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 {
2378
506
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
506
    const auto filtered = filter(results);
2384
2385
506
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
85
        return;
2388
85
    }
2389
2390
421
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
1.16k
    for (size_t i = 1; i < filtered.size(); i++) {
2395
743
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
743
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
743
        const bool equal = *prev == *cur;
2399
2400
743
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
743
    }
2417
421
}
Unexecuted instantiation: 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
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECCSI_Sign>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECCSI_Sign> > > const&, std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECCSI_Signature> >, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, std::__1::optional<cryptofuzz::component::ECCSI_Signature> > > > const&, unsigned char const*, unsigned long) const
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
2377
620
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 {
2378
620
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
620
    const auto filtered = filter(results);
2384
2385
620
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
362
        return;
2388
362
    }
2389
2390
258
    if ( dontCompare(operations[0].second) == true ) {
2391
196
        return;
2392
196
    }
2393
2394
159
    for (size_t i = 1; i < filtered.size(); i++) {
2395
97
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
97
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
97
        const bool equal = *prev == *cur;
2399
2400
97
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
97
    }
2417
62
}
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
Line
Count
Source
2377
139
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 {
2378
139
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
139
    const auto filtered = filter(results);
2384
2385
139
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
76
        return;
2388
76
    }
2389
2390
63
    if ( dontCompare(operations[0].second) == true ) {
2391
55
        return;
2392
55
    }
2393
2394
23
    for (size_t i = 1; i < filtered.size(); i++) {
2395
15
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
15
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
15
        const bool equal = *prev == *cur;
2399
2400
15
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
15
    }
2417
8
}
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
Line
Count
Source
2377
102
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 {
2378
102
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
102
    const auto filtered = filter(results);
2384
2385
102
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
77
        return;
2388
77
    }
2389
2390
25
    if ( dontCompare(operations[0].second) == true ) {
2391
20
        return;
2392
20
    }
2393
2394
14
    for (size_t i = 1; i < filtered.size(); i++) {
2395
9
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
9
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
9
        const bool equal = *prev == *cur;
2399
2400
9
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
9
    }
2417
5
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECCSI_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECCSI_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
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
2377
272
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 {
2378
272
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
272
    const auto filtered = filter(results);
2384
2385
272
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
141
        return;
2388
141
    }
2389
2390
131
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
318
    for (size_t i = 1; i < filtered.size(); i++) {
2395
187
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
187
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
187
        const bool equal = *prev == *cur;
2399
2400
187
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
187
    }
2417
131
}
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
Line
Count
Source
2377
123
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 {
2378
123
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
123
    const auto filtered = filter(results);
2384
2385
123
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
75
        return;
2388
75
    }
2389
2390
48
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
137
    for (size_t i = 1; i < filtered.size(); i++) {
2395
89
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
89
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
89
        const bool equal = *prev == *cur;
2399
2400
89
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
89
    }
2417
48
}
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
Line
Count
Source
2377
88
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 {
2378
88
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
88
    const auto filtered = filter(results);
2384
2385
88
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
75
        return;
2388
75
    }
2389
2390
13
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
37
    for (size_t i = 1; i < filtered.size(); i++) {
2395
24
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
24
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
24
        const bool equal = *prev == *cur;
2399
2400
24
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
24
    }
2417
13
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DSA_Verify>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DSA_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::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DSA_PrivateToPublic>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::DSA_PrivateToPublic> > > 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
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
2377
75
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 {
2378
75
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
75
    const auto filtered = filter(results);
2384
2385
75
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
66
        return;
2388
66
    }
2389
2390
9
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
22
    for (size_t i = 1; i < filtered.size(); i++) {
2395
13
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
13
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
13
        const bool equal = *prev == *cur;
2399
2400
13
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
13
    }
2417
9
}
Unexecuted instantiation: 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
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
2377
122
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 {
2378
122
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
122
    const auto filtered = filter(results);
2384
2385
122
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
115
        return;
2388
115
    }
2389
2390
7
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
19
    for (size_t i = 1; i < filtered.size(); i++) {
2395
12
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
12
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
12
        const bool equal = *prev == *cur;
2399
2400
12
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
12
    }
2417
7
}
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
2377
314
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 {
2378
314
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
314
    const auto filtered = filter(results);
2384
2385
314
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
250
        return;
2388
250
    }
2389
2390
64
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
147
    for (size_t i = 1; i < filtered.size(); i++) {
2395
83
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
83
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
83
        const bool equal = *prev == *cur;
2399
2400
83
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
83
    }
2417
64
}
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
Line
Count
Source
2377
86
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 {
2378
86
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
86
    const auto filtered = filter(results);
2384
2385
86
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
75
        return;
2388
75
    }
2389
2390
11
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
28
    for (size_t i = 1; i < filtered.size(); i++) {
2395
17
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
17
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
17
        const bool equal = *prev == *cur;
2399
2400
17
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
17
    }
2417
11
}
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
Line
Count
Source
2377
267
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 {
2378
267
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
267
    const auto filtered = filter(results);
2384
2385
267
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
240
        return;
2388
240
    }
2389
2390
27
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
72
    for (size_t i = 1; i < filtered.size(); i++) {
2395
45
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
45
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
45
        const bool equal = *prev == *cur;
2399
2400
45
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
45
    }
2417
27
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::compare(std::__1::vector<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Cmp>, std::__1::allocator<std::__1::pair<std::__1::shared_ptr<cryptofuzz::Module>, cryptofuzz::operation::ECC_Point_Cmp> > > 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::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
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
2377
4.43k
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 {
2378
4.43k
    if ( results.size() < 2 ) {
2379
        /* Nothing to compare. Don't even bother filtering. */
2380
0
        return;
2381
0
    }
2382
2383
4.43k
    const auto filtered = filter(results);
2384
2385
4.43k
    if ( filtered.size() < 2 ) {
2386
        /* Nothing to compare */
2387
334
        return;
2388
334
    }
2389
2390
4.09k
    if ( dontCompare(operations[0].second) == true ) {
2391
0
        return;
2392
0
    }
2393
2394
12.3k
    for (size_t i = 1; i < filtered.size(); i++) {
2395
8.24k
        const std::optional<ResultType>& prev = filtered[i-1].second;
2396
8.24k
        const std::optional<ResultType>& cur = filtered[i].second;
2397
2398
8.24k
        const bool equal = *prev == *cur;
2399
2400
8.24k
        if ( !equal ) {
2401
            /* Reconstruct operation */
2402
0
            const auto op = getOp(nullptr, data, size);
2403
2404
0
            printf("Difference detected\n\n");
2405
0
            printf("Operation:\n%s\n", op.ToString().c_str());
2406
0
            printf("Module %s result:\n\n%s\n\n", filtered[i-1].first->name.c_str(), util::ToString(*prev).c_str());
2407
0
            printf("Module %s result:\n\n%s\n\n", filtered[i].first->name.c_str(), util::ToString(*cur).c_str());
2408
2409
0
            abort(
2410
0
                    {filtered[i-1].first->name.c_str(), filtered[i].first->name.c_str()},
2411
0
                    op.Name(),
2412
0
                    op.GetAlgorithmString(),
2413
0
                    "difference"
2414
0
            );
2415
0
        }
2416
8.24k
    }
2417
4.09k
}
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
2418
2419
template <class ResultType, class OperationType>
2420
0
void ExecutorBase<ResultType, OperationType>::abort(std::vector<std::string> moduleNames, const std::string operation, const std::string algorithm, const std::string reason) const {
2421
0
    std::sort(moduleNames.begin(), moduleNames.end());
2422
2423
0
    printf("CPU:\n");
2424
0
    system("cat /proc/cpuinfo | grep '^model name' | head -n1");
2425
0
    system("cat /proc/cpuinfo | grep '^flags' | head -n1");
2426
2427
0
    printf("Assertion failure: ");
2428
0
    for (const auto& moduleName : moduleNames) {
2429
0
        printf("%s-", moduleName.c_str());
2430
0
    }
2431
0
    printf("%s-%s-%s\n", operation.c_str(), algorithm.c_str(), reason.c_str());
2432
0
    fflush(stdout);
2433
2434
0
    ::abort();
2435
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::ECCSI_Signature, cryptofuzz::operation::ECCSI_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::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::ECCSI_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::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<bool, cryptofuzz::operation::DSA_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::DSA_Signature, cryptofuzz::operation::DSA_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::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::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::DSA_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::BignumPair, cryptofuzz::operation::DSA_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::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<bool, cryptofuzz::operation::ECC_Point_Cmp>::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
2436
2437
template <class ResultType, class OperationType>
2438
10.4k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
10.4k
    (void)parentDs;
2440
10.4k
    return std::move(op);
2441
10.4k
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Digest) const
Line
Count
Source
2438
840
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
840
    (void)parentDs;
2440
840
    return std::move(op);
2441
840
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::HMAC) const
Line
Count
Source
2438
737
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
737
    (void)parentDs;
2440
737
    return std::move(op);
2441
737
}
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
2438
596
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
596
    (void)parentDs;
2440
596
    return std::move(op);
2441
596
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_ValidatePubkey) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_GenerateKeyPair) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECCSI_Sign) const
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDSA_Sign) const
Line
Count
Source
2438
863
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
863
    (void)parentDs;
2440
863
    return std::move(op);
2441
863
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECGDSA_Sign) const
Line
Count
Source
2438
278
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
278
    (void)parentDs;
2440
278
    return std::move(op);
2441
278
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECRDSA_Sign) const
Line
Count
Source
2438
221
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
221
    (void)parentDs;
2440
221
    return std::move(op);
2441
221
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::Schnorr_Sign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECCSI_Verify) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDSA_Verify) const
Line
Count
Source
2438
369
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
369
    (void)parentDs;
2440
369
    return std::move(op);
2441
369
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECGDSA_Verify) const
Line
Count
Source
2438
243
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
243
    (void)parentDs;
2440
243
    return std::move(op);
2441
243
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECRDSA_Verify) const
Line
Count
Source
2438
184
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
184
    (void)parentDs;
2440
184
    return std::move(op);
2441
184
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DSA_Verify) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DSA_Sign) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DSA_GenerateParameters) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DSA_PrivateToPublic) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DSA_GenerateKeyPair) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECDH_Derive) const
Line
Count
Source
2438
146
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
146
    (void)parentDs;
2440
146
    return std::move(op);
2441
146
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECIES_Encrypt) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECIES_Decrypt) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Add) const
Line
Count
Source
2438
211
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
211
    (void)parentDs;
2440
211
    return std::move(op);
2441
211
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Mul) const
Line
Count
Source
2438
386
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
386
    (void)parentDs;
2440
386
    return std::move(op);
2441
386
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Neg) const
Line
Count
Source
2438
145
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
145
    (void)parentDs;
2440
145
    return std::move(op);
2441
145
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Dbl) const
Line
Count
Source
2438
370
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
370
    (void)parentDs;
2440
370
    return std::move(op);
2441
370
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::ECC_Point_Cmp) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DH_GenerateKeyPair) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::DH_Derive) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getOpPostprocess(fuzzing::datasource::Datasource*, cryptofuzz::operation::BignumCalc) const
Line
Count
Source
2438
4.86k
OperationType ExecutorBase<ResultType, OperationType>::getOpPostprocess(Datasource* parentDs, OperationType op) const {
2439
4.86k
    (void)parentDs;
2440
4.86k
    return std::move(op);
2441
4.86k
}
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
2442
2443
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_381_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2444
0
    (void)parentDs;
2445
0
    op.modulo = modulo;
2446
0
    return op;
2447
0
}
2448
2449
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_381_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2450
0
    (void)parentDs;
2451
0
    op.modulo = modulo;
2452
0
    return op;
2453
0
}
2454
2455
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_377_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2456
0
    (void)parentDs;
2457
0
    op.modulo = modulo;
2458
0
    return op;
2459
0
}
2460
2461
0
operation::BignumCalc ExecutorBignumCalc_Mod_BLS12_377_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2462
0
    (void)parentDs;
2463
0
    op.modulo = modulo;
2464
0
    return op;
2465
0
}
2466
2467
0
operation::BignumCalc ExecutorBignumCalc_Mod_BN128_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2468
0
    (void)parentDs;
2469
0
    op.modulo = modulo;
2470
0
    return op;
2471
0
}
2472
2473
0
operation::BignumCalc ExecutorBignumCalc_Mod_BN128_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2474
0
    (void)parentDs;
2475
0
    op.modulo = modulo;
2476
0
    return op;
2477
0
}
2478
2479
0
operation::BignumCalc ExecutorBignumCalc_Mod_ED25519::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2480
0
    (void)parentDs;
2481
0
    op.modulo = modulo;
2482
0
    return op;
2483
0
}
2484
2485
0
operation::BignumCalc ExecutorBignumCalc_Mod_Edwards_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2486
0
    (void)parentDs;
2487
0
    op.modulo = modulo;
2488
0
    return op;
2489
0
}
2490
2491
0
operation::BignumCalc ExecutorBignumCalc_Mod_Edwards_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2492
0
    (void)parentDs;
2493
0
    op.modulo = modulo;
2494
0
    return op;
2495
0
}
2496
2497
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT4_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2498
0
    (void)parentDs;
2499
0
    op.modulo = modulo;
2500
0
    return op;
2501
0
}
2502
2503
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT4_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2504
0
    (void)parentDs;
2505
0
    op.modulo = modulo;
2506
0
    return op;
2507
0
}
2508
2509
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT6_R::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2510
0
    (void)parentDs;
2511
0
    op.modulo = modulo;
2512
0
    return op;
2513
0
}
2514
2515
0
operation::BignumCalc ExecutorBignumCalc_Mod_MNT6_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2516
0
    (void)parentDs;
2517
0
    op.modulo = modulo;
2518
0
    return op;
2519
0
}
2520
2521
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp64::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2522
0
    (void)parentDs;
2523
0
    op.modulo = modulo;
2524
0
    return op;
2525
0
}
2526
2527
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp128::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2528
0
    (void)parentDs;
2529
0
    op.modulo = modulo;
2530
0
    return op;
2531
0
}
2532
2533
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp256::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2534
0
    (void)parentDs;
2535
0
    op.modulo = modulo;
2536
0
    return op;
2537
0
}
2538
2539
0
operation::BignumCalc ExecutorBignumCalc_Mod_2Exp512::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2540
0
    (void)parentDs;
2541
0
    op.modulo = modulo;
2542
0
    return op;
2543
0
}
2544
2545
0
operation::BignumCalc ExecutorBignumCalc_Mod_SECP256K1::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2546
0
    (void)parentDs;
2547
0
    op.modulo = modulo;
2548
0
    return op;
2549
0
}
2550
2551
0
operation::BignumCalc ExecutorBignumCalc_Mod_SECP256K1_P::getOpPostprocess(Datasource* parentDs, operation::BignumCalc op) const {
2552
0
    (void)parentDs;
2553
0
    op.modulo = modulo;
2554
0
    return op;
2555
0
}
2556
2557
template <class ResultType, class OperationType>
2558
10.5k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
10.5k
    Datasource ds(data, size);
2560
10.5k
    if ( parentDs != nullptr ) {
2561
10.5k
        auto modifier = parentDs->GetData(0);
2562
10.5k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
10.5k
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
10.5k
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
847
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
847
    Datasource ds(data, size);
2560
847
    if ( parentDs != nullptr ) {
2561
847
        auto modifier = parentDs->GetData(0);
2562
847
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
847
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
847
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
744
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
744
    Datasource ds(data, size);
2560
744
    if ( parentDs != nullptr ) {
2561
744
        auto modifier = parentDs->GetData(0);
2562
744
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
744
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
744
}
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
2558
603
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
603
    Datasource ds(data, size);
2560
603
    if ( parentDs != nullptr ) {
2561
603
        auto modifier = parentDs->GetData(0);
2562
603
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
603
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
603
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
870
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
870
    Datasource ds(data, size);
2560
870
    if ( parentDs != nullptr ) {
2561
870
        auto modifier = parentDs->GetData(0);
2562
870
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
870
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
870
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
283
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
283
    Datasource ds(data, size);
2560
283
    if ( parentDs != nullptr ) {
2561
283
        auto modifier = parentDs->GetData(0);
2562
283
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
283
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
283
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
225
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
225
    Datasource ds(data, size);
2560
225
    if ( parentDs != nullptr ) {
2561
225
        auto modifier = parentDs->GetData(0);
2562
225
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
225
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
225
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::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
2558
376
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
376
    Datasource ds(data, size);
2560
376
    if ( parentDs != nullptr ) {
2561
376
        auto modifier = parentDs->GetData(0);
2562
376
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
376
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
376
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
249
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
249
    Datasource ds(data, size);
2560
249
    if ( parentDs != nullptr ) {
2561
249
        auto modifier = parentDs->GetData(0);
2562
249
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
249
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
249
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
189
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
189
    Datasource ds(data, size);
2560
189
    if ( parentDs != nullptr ) {
2561
189
        auto modifier = parentDs->GetData(0);
2562
189
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
189
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
189
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::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
2558
155
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
155
    Datasource ds(data, size);
2560
155
    if ( parentDs != nullptr ) {
2561
155
        auto modifier = parentDs->GetData(0);
2562
155
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
155
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
155
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
217
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
217
    Datasource ds(data, size);
2560
217
    if ( parentDs != nullptr ) {
2561
217
        auto modifier = parentDs->GetData(0);
2562
217
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
217
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
217
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
391
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
391
    Datasource ds(data, size);
2560
391
    if ( parentDs != nullptr ) {
2561
391
        auto modifier = parentDs->GetData(0);
2562
391
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
391
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
391
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
148
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
148
    Datasource ds(data, size);
2560
148
    if ( parentDs != nullptr ) {
2561
148
        auto modifier = parentDs->GetData(0);
2562
148
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
148
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
148
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
375
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
375
    Datasource ds(data, size);
2560
375
    if ( parentDs != nullptr ) {
2561
375
        auto modifier = parentDs->GetData(0);
2562
375
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
375
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
375
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getOp(fuzzing::datasource::Datasource*, unsigned char const*, unsigned long) const
Line
Count
Source
2558
4.87k
OperationType ExecutorBase<ResultType, OperationType>::getOp(Datasource* parentDs, const uint8_t* data, const size_t size) const {
2559
4.87k
    Datasource ds(data, size);
2560
4.87k
    if ( parentDs != nullptr ) {
2561
4.87k
        auto modifier = parentDs->GetData(0);
2562
4.87k
        return getOpPostprocess(parentDs, std::move( OperationType(ds, component::Modifier(modifier.data(), modifier.size())) ) );
2563
4.87k
    } else {
2564
0
        return std::move( OperationType(ds, component::Modifier(nullptr, 0)) );
2565
0
    }
2566
4.87k
}
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
2567
2568
template <class ResultType, class OperationType>
2569
10.4k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
10.4k
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
10.4k
    if ( options.forceModule != std::nullopt ) {
2574
10.3k
        moduleID = *options.forceModule;
2575
10.3k
    }
2576
2577
    /* Skip if this is a disabled module */
2578
10.4k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
10.4k
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
10.4k
    return modules.at(moduleID);
2587
10.4k
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
840
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
840
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
840
    if ( options.forceModule != std::nullopt ) {
2574
830
        moduleID = *options.forceModule;
2575
830
    }
2576
2577
    /* Skip if this is a disabled module */
2578
840
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
840
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
840
    return modules.at(moduleID);
2587
840
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
737
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
737
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
737
    if ( options.forceModule != std::nullopt ) {
2574
733
        moduleID = *options.forceModule;
2575
733
    }
2576
2577
    /* Skip if this is a disabled module */
2578
737
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
737
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
737
    return modules.at(moduleID);
2587
737
}
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
2569
596
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
596
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
596
    if ( options.forceModule != std::nullopt ) {
2574
587
        moduleID = *options.forceModule;
2575
587
    }
2576
2577
    /* Skip if this is a disabled module */
2578
596
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
596
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
596
    return modules.at(moduleID);
2587
596
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
863
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
863
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
863
    if ( options.forceModule != std::nullopt ) {
2574
858
        moduleID = *options.forceModule;
2575
858
    }
2576
2577
    /* Skip if this is a disabled module */
2578
863
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
863
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
863
    return modules.at(moduleID);
2587
863
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
278
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
278
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
278
    if ( options.forceModule != std::nullopt ) {
2574
273
        moduleID = *options.forceModule;
2575
273
    }
2576
2577
    /* Skip if this is a disabled module */
2578
278
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
278
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
278
    return modules.at(moduleID);
2587
278
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
221
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
221
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
221
    if ( options.forceModule != std::nullopt ) {
2574
217
        moduleID = *options.forceModule;
2575
217
    }
2576
2577
    /* Skip if this is a disabled module */
2578
221
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
221
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
221
    return modules.at(moduleID);
2587
221
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
369
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
369
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
369
    if ( options.forceModule != std::nullopt ) {
2574
368
        moduleID = *options.forceModule;
2575
368
    }
2576
2577
    /* Skip if this is a disabled module */
2578
369
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
369
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
369
    return modules.at(moduleID);
2587
369
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
243
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
243
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
243
    if ( options.forceModule != std::nullopt ) {
2574
239
        moduleID = *options.forceModule;
2575
239
    }
2576
2577
    /* Skip if this is a disabled module */
2578
243
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
243
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
243
    return modules.at(moduleID);
2587
243
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
184
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
184
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
184
    if ( options.forceModule != std::nullopt ) {
2574
181
        moduleID = *options.forceModule;
2575
181
    }
2576
2577
    /* Skip if this is a disabled module */
2578
184
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
184
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
184
    return modules.at(moduleID);
2587
184
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECDH_Derive>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
146
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
146
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
146
    if ( options.forceModule != std::nullopt ) {
2574
141
        moduleID = *options.forceModule;
2575
141
    }
2576
2577
    /* Skip if this is a disabled module */
2578
146
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
146
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
146
    return modules.at(moduleID);
2587
146
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
211
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
211
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
211
    if ( options.forceModule != std::nullopt ) {
2574
207
        moduleID = *options.forceModule;
2575
207
    }
2576
2577
    /* Skip if this is a disabled module */
2578
211
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
211
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
211
    return modules.at(moduleID);
2587
211
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
386
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
386
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
386
    if ( options.forceModule != std::nullopt ) {
2574
378
        moduleID = *options.forceModule;
2575
378
    }
2576
2577
    /* Skip if this is a disabled module */
2578
386
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
386
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
386
    return modules.at(moduleID);
2587
386
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
145
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
145
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
145
    if ( options.forceModule != std::nullopt ) {
2574
141
        moduleID = *options.forceModule;
2575
141
    }
2576
2577
    /* Skip if this is a disabled module */
2578
145
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
145
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
145
    return modules.at(moduleID);
2587
145
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
370
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
370
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
370
    if ( options.forceModule != std::nullopt ) {
2574
361
        moduleID = *options.forceModule;
2575
361
    }
2576
2577
    /* Skip if this is a disabled module */
2578
370
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
370
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
370
    return modules.at(moduleID);
2587
370
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::getModule(fuzzing::datasource::Datasource&) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::getModule(fuzzing::datasource::Datasource&) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::getModule(fuzzing::datasource::Datasource&) const
Line
Count
Source
2569
4.86k
std::shared_ptr<Module> ExecutorBase<ResultType, OperationType>::getModule(Datasource& ds) const {
2570
4.86k
    auto moduleID = ds.Get<uint64_t>();
2571
2572
    /* Override the extracted module ID with the preferred one, if specified */
2573
4.86k
    if ( options.forceModule != std::nullopt ) {
2574
4.86k
        moduleID = *options.forceModule;
2575
4.86k
    }
2576
2577
    /* Skip if this is a disabled module */
2578
4.86k
    if ( options.disableModules.HaveExplicit(moduleID) ) {
2579
0
        return nullptr;
2580
0
    }
2581
2582
4.86k
    if ( modules.find(moduleID) == modules.end() ) {
2583
0
        return nullptr;
2584
0
    }
2585
2586
4.86k
    return modules.at(moduleID);
2587
4.86k
}
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
2588
2589
template <class ResultType, class OperationType>
2590
8.19k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
8.19k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
8.19k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
10.5k
    do {
2596
10.5k
        auto op = getOp(&parentDs, data, size);
2597
10.5k
        auto module = getModule(parentDs);
2598
10.5k
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
10.5k
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
10.5k
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
148
            break;
2607
148
        }
2608
10.5k
    } while ( parentDs.Get<bool>() == true );
2609
2610
8.19k
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
8.19k
#if 1
2616
8.19k
    {
2617
8.19k
        std::set<uint64_t> moduleIDs;
2618
31.9k
        for (const auto& m : modules ) {
2619
31.9k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
31.9k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
31.9k
            moduleIDs.insert(moduleID);
2627
31.9k
        }
2628
2629
8.19k
        std::set<uint64_t> operationModuleIDs;
2630
10.1k
        for (const auto& op : operations) {
2631
10.1k
            operationModuleIDs.insert(op.first->ID);
2632
10.1k
        }
2633
2634
8.19k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
8.19k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
8.19k
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
23.9k
        for (const auto& id : addModuleIDs) {
2639
23.9k
            operations.push_back({ modules.at(id), operations[0].second});
2640
23.9k
        }
2641
8.19k
    }
2642
8.19k
#endif
2643
2644
8.19k
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
8.19k
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
42.2k
    for (size_t i = 0; i < operations.size(); i++) {
2652
34.0k
        auto& operation = operations[i];
2653
2654
34.0k
        auto& module = operation.first;
2655
34.0k
        auto& op = operation.second;
2656
2657
34.0k
        if ( i > 0 ) {
2658
26.0k
            auto& prevModule = operations[i-1].first;
2659
26.0k
            auto& prevOp = operations[i].second;
2660
2661
26.0k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
2.13k
                auto& curModifier = op.modifier.GetVectorPtr();
2663
2.13k
                if ( curModifier.size() == 0 ) {
2664
693k
                    for (size_t j = 0; j < 512; j++) {
2665
691k
                        curModifier.push_back(1);
2666
691k
                    }
2667
1.35k
                } else {
2668
127k
                    for (auto& c : curModifier) {
2669
127k
                        c++;
2670
127k
                    }
2671
779
                }
2672
2.13k
            }
2673
26.0k
        }
2674
2675
34.0k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
34.0k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
34.0k
        const auto& result = results.back();
2682
2683
34.0k
        if ( result.second != std::nullopt ) {
2684
18.1k
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
18.1k
        }
2691
2692
34.0k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
34.0k
        if ( options.disableTests == false ) {
2701
34.0k
            tests::test(op, result.second);
2702
34.0k
        }
2703
2704
34.0k
        postprocess(module, op, result);
2705
34.0k
    }
2706
2707
8.19k
    if ( options.noCompare == false ) {
2708
7.97k
        compare(operations, results, data, size);
2709
7.97k
    }
2710
8.19k
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::Digest>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
487
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
487
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
487
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
847
    do {
2596
847
        auto op = getOp(&parentDs, data, size);
2597
847
        auto module = getModule(parentDs);
2598
847
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
847
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
847
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
1
            break;
2607
1
        }
2608
847
    } while ( parentDs.Get<bool>() == true );
2609
2610
487
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
487
#if 1
2616
487
    {
2617
487
        std::set<uint64_t> moduleIDs;
2618
1.85k
        for (const auto& m : modules ) {
2619
1.85k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
1.85k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
1.85k
            moduleIDs.insert(moduleID);
2627
1.85k
        }
2628
2629
487
        std::set<uint64_t> operationModuleIDs;
2630
779
        for (const auto& op : operations) {
2631
779
            operationModuleIDs.insert(op.first->ID);
2632
779
        }
2633
2634
487
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
487
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
487
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
1.39k
        for (const auto& id : addModuleIDs) {
2639
1.39k
            operations.push_back({ modules.at(id), operations[0].second});
2640
1.39k
        }
2641
487
    }
2642
487
#endif
2643
2644
487
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
487
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
2.65k
    for (size_t i = 0; i < operations.size(); i++) {
2652
2.17k
        auto& operation = operations[i];
2653
2654
2.17k
        auto& module = operation.first;
2655
2.17k
        auto& op = operation.second;
2656
2657
2.17k
        if ( i > 0 ) {
2658
1.70k
            auto& prevModule = operations[i-1].first;
2659
1.70k
            auto& prevOp = operations[i].second;
2660
2661
1.70k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
315
                auto& curModifier = op.modifier.GetVectorPtr();
2663
315
                if ( curModifier.size() == 0 ) {
2664
130k
                    for (size_t j = 0; j < 512; j++) {
2665
130k
                        curModifier.push_back(1);
2666
130k
                    }
2667
255
                } else {
2668
320
                    for (auto& c : curModifier) {
2669
320
                        c++;
2670
320
                    }
2671
60
                }
2672
315
            }
2673
1.70k
        }
2674
2675
2.17k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
2.17k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
2.17k
        const auto& result = results.back();
2682
2683
2.17k
        if ( result.second != std::nullopt ) {
2684
1.34k
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
1.34k
        }
2691
2692
2.17k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
2.17k
        if ( options.disableTests == false ) {
2701
2.17k
            tests::test(op, result.second);
2702
2.17k
        }
2703
2704
2.17k
        postprocess(module, op, result);
2705
2.17k
    }
2706
2707
487
    if ( options.noCompare == false ) {
2708
464
        compare(operations, results, data, size);
2709
464
    }
2710
487
}
cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::HMAC>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
381
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
381
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
381
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
744
    do {
2596
744
        auto op = getOp(&parentDs, data, size);
2597
744
        auto module = getModule(parentDs);
2598
744
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
744
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
744
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
3
            break;
2607
3
        }
2608
744
    } while ( parentDs.Get<bool>() == true );
2609
2610
381
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
381
#if 1
2616
381
    {
2617
381
        std::set<uint64_t> moduleIDs;
2618
1.46k
        for (const auto& m : modules ) {
2619
1.46k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
1.46k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
1.46k
            moduleIDs.insert(moduleID);
2627
1.46k
        }
2628
2629
381
        std::set<uint64_t> operationModuleIDs;
2630
695
        for (const auto& op : operations) {
2631
695
            operationModuleIDs.insert(op.first->ID);
2632
695
        }
2633
2634
381
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
381
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
381
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
1.10k
        for (const auto& id : addModuleIDs) {
2639
1.10k
            operations.push_back({ modules.at(id), operations[0].second});
2640
1.10k
        }
2641
381
    }
2642
381
#endif
2643
2644
381
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
381
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
2.17k
    for (size_t i = 0; i < operations.size(); i++) {
2652
1.79k
        auto& operation = operations[i];
2653
2654
1.79k
        auto& module = operation.first;
2655
1.79k
        auto& op = operation.second;
2656
2657
1.79k
        if ( i > 0 ) {
2658
1.42k
            auto& prevModule = operations[i-1].first;
2659
1.42k
            auto& prevOp = operations[i].second;
2660
2661
1.42k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
328
                auto& curModifier = op.modifier.GetVectorPtr();
2663
328
                if ( curModifier.size() == 0 ) {
2664
109k
                    for (size_t j = 0; j < 512; j++) {
2665
109k
                        curModifier.push_back(1);
2666
109k
                    }
2667
213
                } else {
2668
605
                    for (auto& c : curModifier) {
2669
605
                        c++;
2670
605
                    }
2671
115
                }
2672
328
            }
2673
1.42k
        }
2674
2675
1.79k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
1.79k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
1.79k
        const auto& result = results.back();
2682
2683
1.79k
        if ( result.second != std::nullopt ) {
2684
722
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
722
        }
2691
2692
1.79k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
1.79k
        if ( options.disableTests == false ) {
2701
1.79k
            tests::test(op, result.second);
2702
1.79k
        }
2703
2704
1.79k
        postprocess(module, op, result);
2705
1.79k
    }
2706
2707
381
    if ( options.noCompare == false ) {
2708
367
        compare(operations, results, data, size);
2709
367
    }
2710
381
}
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
2590
527
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
527
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
527
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
603
    do {
2596
603
        auto op = getOp(&parentDs, data, size);
2597
603
        auto module = getModule(parentDs);
2598
603
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
603
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
603
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
8
            break;
2607
8
        }
2608
603
    } while ( parentDs.Get<bool>() == true );
2609
2610
527
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
527
#if 1
2616
527
    {
2617
527
        std::set<uint64_t> moduleIDs;
2618
2.02k
        for (const auto& m : modules ) {
2619
2.02k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
2.02k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
2.02k
            moduleIDs.insert(moduleID);
2627
2.02k
        }
2628
2629
527
        std::set<uint64_t> operationModuleIDs;
2630
568
        for (const auto& op : operations) {
2631
568
            operationModuleIDs.insert(op.first->ID);
2632
568
        }
2633
2634
527
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
527
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
527
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
1.51k
        for (const auto& id : addModuleIDs) {
2639
1.51k
            operations.push_back({ modules.at(id), operations[0].second});
2640
1.51k
        }
2641
527
    }
2642
527
#endif
2643
2644
527
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
527
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
2.61k
    for (size_t i = 0; i < operations.size(); i++) {
2652
2.08k
        auto& operation = operations[i];
2653
2654
2.08k
        auto& module = operation.first;
2655
2.08k
        auto& op = operation.second;
2656
2657
2.08k
        if ( i > 0 ) {
2658
1.58k
            auto& prevModule = operations[i-1].first;
2659
1.58k
            auto& prevOp = operations[i].second;
2660
2661
1.58k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
62
                auto& curModifier = op.modifier.GetVectorPtr();
2663
62
                if ( curModifier.size() == 0 ) {
2664
20.5k
                    for (size_t j = 0; j < 512; j++) {
2665
20.4k
                        curModifier.push_back(1);
2666
20.4k
                    }
2667
40
                } else {
2668
292
                    for (auto& c : curModifier) {
2669
292
                        c++;
2670
292
                    }
2671
22
                }
2672
62
            }
2673
1.58k
        }
2674
2675
2.08k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
2.08k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
2.08k
        const auto& result = results.back();
2682
2683
2.08k
        if ( result.second != std::nullopt ) {
2684
1.20k
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
1.20k
        }
2691
2692
2.08k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
2.08k
        if ( options.disableTests == false ) {
2701
2.08k
            tests::test(op, result.second);
2702
2.08k
        }
2703
2704
2.08k
        postprocess(module, op, result);
2705
2.08k
    }
2706
2707
527
    if ( options.noCompare == false ) {
2708
506
        compare(operations, results, data, size);
2709
506
    }
2710
527
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_ValidatePubkey>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECC_KeyPair, cryptofuzz::operation::ECC_GenerateKeyPair>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECCSI_Signature, cryptofuzz::operation::ECCSI_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
638
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
638
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
638
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
870
    do {
2596
870
        auto op = getOp(&parentDs, data, size);
2597
870
        auto module = getModule(parentDs);
2598
870
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
870
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
870
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
23
            break;
2607
23
        }
2608
870
    } while ( parentDs.Get<bool>() == true );
2609
2610
638
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
638
#if 1
2616
638
    {
2617
638
        std::set<uint64_t> moduleIDs;
2618
2.48k
        for (const auto& m : modules ) {
2619
2.48k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
2.48k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
2.48k
            moduleIDs.insert(moduleID);
2627
2.48k
        }
2628
2629
638
        std::set<uint64_t> operationModuleIDs;
2630
835
        for (const auto& op : operations) {
2631
835
            operationModuleIDs.insert(op.first->ID);
2632
835
        }
2633
2634
638
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
638
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
638
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
1.86k
        for (const auto& id : addModuleIDs) {
2639
1.86k
            operations.push_back({ modules.at(id), operations[0].second});
2640
1.86k
        }
2641
638
    }
2642
638
#endif
2643
2644
638
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
638
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
3.33k
    for (size_t i = 0; i < operations.size(); i++) {
2652
2.69k
        auto& operation = operations[i];
2653
2654
2.69k
        auto& module = operation.first;
2655
2.69k
        auto& op = operation.second;
2656
2657
2.69k
        if ( i > 0 ) {
2658
2.07k
            auto& prevModule = operations[i-1].first;
2659
2.07k
            auto& prevOp = operations[i].second;
2660
2661
2.07k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
215
                auto& curModifier = op.modifier.GetVectorPtr();
2663
215
                if ( curModifier.size() == 0 ) {
2664
61.0k
                    for (size_t j = 0; j < 512; j++) {
2665
60.9k
                        curModifier.push_back(1);
2666
60.9k
                    }
2667
119
                } else {
2668
12.6k
                    for (auto& c : curModifier) {
2669
12.6k
                        c++;
2670
12.6k
                    }
2671
96
                }
2672
215
            }
2673
2.07k
        }
2674
2675
2.69k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
2.69k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
2.69k
        const auto& result = results.back();
2682
2683
2.69k
        if ( result.second != std::nullopt ) {
2684
895
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
895
        }
2691
2692
2.69k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
2.69k
        if ( options.disableTests == false ) {
2701
2.69k
            tests::test(op, result.second);
2702
2.69k
        }
2703
2704
2.69k
        postprocess(module, op, result);
2705
2.69k
    }
2706
2707
638
    if ( options.noCompare == false ) {
2708
620
        compare(operations, results, data, size);
2709
620
    }
2710
638
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECGDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
152
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
152
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
152
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
283
    do {
2596
283
        auto op = getOp(&parentDs, data, size);
2597
283
        auto module = getModule(parentDs);
2598
283
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
283
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
283
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
10
            break;
2607
10
        }
2608
283
    } while ( parentDs.Get<bool>() == true );
2609
2610
152
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
152
#if 1
2616
152
    {
2617
152
        std::set<uint64_t> moduleIDs;
2618
556
        for (const auto& m : modules ) {
2619
556
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
556
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
556
            moduleIDs.insert(moduleID);
2627
556
        }
2628
2629
152
        std::set<uint64_t> operationModuleIDs;
2630
264
        for (const auto& op : operations) {
2631
264
            operationModuleIDs.insert(op.first->ID);
2632
264
        }
2633
2634
152
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
152
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
152
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
417
        for (const auto& id : addModuleIDs) {
2639
417
            operations.push_back({ modules.at(id), operations[0].second});
2640
417
        }
2641
152
    }
2642
152
#endif
2643
2644
152
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
152
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
833
    for (size_t i = 0; i < operations.size(); i++) {
2652
681
        auto& operation = operations[i];
2653
2654
681
        auto& module = operation.first;
2655
681
        auto& op = operation.second;
2656
2657
681
        if ( i > 0 ) {
2658
542
            auto& prevModule = operations[i-1].first;
2659
542
            auto& prevOp = operations[i].second;
2660
2661
542
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
125
                auto& curModifier = op.modifier.GetVectorPtr();
2663
125
                if ( curModifier.size() == 0 ) {
2664
36.9k
                    for (size_t j = 0; j < 512; j++) {
2665
36.8k
                        curModifier.push_back(1);
2666
36.8k
                    }
2667
72
                } else {
2668
10.7k
                    for (auto& c : curModifier) {
2669
10.7k
                        c++;
2670
10.7k
                    }
2671
53
                }
2672
125
            }
2673
542
        }
2674
2675
681
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
681
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
681
        const auto& result = results.back();
2682
2683
681
        if ( result.second != std::nullopt ) {
2684
191
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
191
        }
2691
2692
681
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
681
        if ( options.disableTests == false ) {
2701
681
            tests::test(op, result.second);
2702
681
        }
2703
2704
681
        postprocess(module, op, result);
2705
681
    }
2706
2707
152
    if ( options.noCompare == false ) {
2708
139
        compare(operations, results, data, size);
2709
139
    }
2710
152
}
cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::ECRDSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
112
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
112
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
112
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
225
    do {
2596
225
        auto op = getOp(&parentDs, data, size);
2597
225
        auto module = getModule(parentDs);
2598
225
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
225
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
225
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
8
            break;
2607
8
        }
2608
225
    } while ( parentDs.Get<bool>() == true );
2609
2610
112
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
112
#if 1
2616
112
    {
2617
112
        std::set<uint64_t> moduleIDs;
2618
408
        for (const auto& m : modules ) {
2619
408
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
408
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
408
            moduleIDs.insert(moduleID);
2627
408
        }
2628
2629
112
        std::set<uint64_t> operationModuleIDs;
2630
207
        for (const auto& op : operations) {
2631
207
            operationModuleIDs.insert(op.first->ID);
2632
207
        }
2633
2634
112
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
112
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
112
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
306
        for (const auto& id : addModuleIDs) {
2639
306
            operations.push_back({ modules.at(id), operations[0].second});
2640
306
        }
2641
112
    }
2642
112
#endif
2643
2644
112
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
112
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
625
    for (size_t i = 0; i < operations.size(); i++) {
2652
513
        auto& operation = operations[i];
2653
2654
513
        auto& module = operation.first;
2655
513
        auto& op = operation.second;
2656
2657
513
        if ( i > 0 ) {
2658
411
            auto& prevModule = operations[i-1].first;
2659
411
            auto& prevOp = operations[i].second;
2660
2661
411
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
105
                auto& curModifier = op.modifier.GetVectorPtr();
2663
105
                if ( curModifier.size() == 0 ) {
2664
33.3k
                    for (size_t j = 0; j < 512; j++) {
2665
33.2k
                        curModifier.push_back(1);
2666
33.2k
                    }
2667
65
                } else {
2668
87.3k
                    for (auto& c : curModifier) {
2669
87.3k
                        c++;
2670
87.3k
                    }
2671
40
                }
2672
105
            }
2673
411
        }
2674
2675
513
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
513
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
513
        const auto& result = results.back();
2682
2683
513
        if ( result.second != std::nullopt ) {
2684
108
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
108
        }
2691
2692
513
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
513
        if ( options.disableTests == false ) {
2701
513
            tests::test(op, result.second);
2702
513
        }
2703
2704
513
        postprocess(module, op, result);
2705
513
    }
2706
2707
112
    if ( options.noCompare == false ) {
2708
102
        compare(operations, results, data, size);
2709
102
    }
2710
112
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::ECDSA_Signature, cryptofuzz::operation::Schnorr_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECCSI_Verify>::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
2590
281
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
281
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
281
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
376
    do {
2596
376
        auto op = getOp(&parentDs, data, size);
2597
376
        auto module = getModule(parentDs);
2598
376
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
376
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
376
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
8
            break;
2607
8
        }
2608
376
    } while ( parentDs.Get<bool>() == true );
2609
2610
281
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
281
#if 1
2616
281
    {
2617
281
        std::set<uint64_t> moduleIDs;
2618
1.08k
        for (const auto& m : modules ) {
2619
1.08k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
1.08k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
1.08k
            moduleIDs.insert(moduleID);
2627
1.08k
        }
2628
2629
281
        std::set<uint64_t> operationModuleIDs;
2630
364
        for (const auto& op : operations) {
2631
364
            operationModuleIDs.insert(op.first->ID);
2632
364
        }
2633
2634
281
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
281
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
281
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
816
        for (const auto& id : addModuleIDs) {
2639
816
            operations.push_back({ modules.at(id), operations[0].second});
2640
816
        }
2641
281
    }
2642
281
#endif
2643
2644
281
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
281
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
1.46k
    for (size_t i = 0; i < operations.size(); i++) {
2652
1.18k
        auto& operation = operations[i];
2653
2654
1.18k
        auto& module = operation.first;
2655
1.18k
        auto& op = operation.second;
2656
2657
1.18k
        if ( i > 0 ) {
2658
908
            auto& prevModule = operations[i-1].first;
2659
908
            auto& prevOp = operations[i].second;
2660
2661
908
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
92
                auto& curModifier = op.modifier.GetVectorPtr();
2663
92
                if ( curModifier.size() == 0 ) {
2664
21.5k
                    for (size_t j = 0; j < 512; j++) {
2665
21.5k
                        curModifier.push_back(1);
2666
21.5k
                    }
2667
50
                } else {
2668
2.78k
                    for (auto& c : curModifier) {
2669
2.78k
                        c++;
2670
2.78k
                    }
2671
50
                }
2672
92
            }
2673
908
        }
2674
2675
1.18k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
1.18k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
1.18k
        const auto& result = results.back();
2682
2683
1.18k
        if ( result.second != std::nullopt ) {
2684
442
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
442
        }
2691
2692
1.18k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
1.18k
        if ( options.disableTests == false ) {
2701
1.18k
            tests::test(op, result.second);
2702
1.18k
        }
2703
2704
1.18k
        postprocess(module, op, result);
2705
1.18k
    }
2706
2707
281
    if ( options.noCompare == false ) {
2708
272
        compare(operations, results, data, size);
2709
272
    }
2710
281
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECGDSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
135
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
135
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
135
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
249
    do {
2596
249
        auto op = getOp(&parentDs, data, size);
2597
249
        auto module = getModule(parentDs);
2598
249
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
249
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
249
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
9
            break;
2607
9
        }
2608
249
    } while ( parentDs.Get<bool>() == true );
2609
2610
135
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
135
#if 1
2616
135
    {
2617
135
        std::set<uint64_t> moduleIDs;
2618
492
        for (const auto& m : modules ) {
2619
492
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
492
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
492
            moduleIDs.insert(moduleID);
2627
492
        }
2628
2629
135
        std::set<uint64_t> operationModuleIDs;
2630
226
        for (const auto& op : operations) {
2631
226
            operationModuleIDs.insert(op.first->ID);
2632
226
        }
2633
2634
135
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
135
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
135
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
369
        for (const auto& id : addModuleIDs) {
2639
369
            operations.push_back({ modules.at(id), operations[0].second});
2640
369
        }
2641
135
    }
2642
135
#endif
2643
2644
135
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
135
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
730
    for (size_t i = 0; i < operations.size(); i++) {
2652
595
        auto& operation = operations[i];
2653
2654
595
        auto& module = operation.first;
2655
595
        auto& op = operation.second;
2656
2657
595
        if ( i > 0 ) {
2658
472
            auto& prevModule = operations[i-1].first;
2659
472
            auto& prevOp = operations[i].second;
2660
2661
472
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
103
                auto& curModifier = op.modifier.GetVectorPtr();
2663
103
                if ( curModifier.size() == 0 ) {
2664
31.8k
                    for (size_t j = 0; j < 512; j++) {
2665
31.7k
                        curModifier.push_back(1);
2666
31.7k
                    }
2667
62
                } else {
2668
4.03k
                    for (auto& c : curModifier) {
2669
4.03k
                        c++;
2670
4.03k
                    }
2671
41
                }
2672
103
            }
2673
472
        }
2674
2675
595
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
595
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
595
        const auto& result = results.back();
2682
2683
595
        if ( result.second != std::nullopt ) {
2684
198
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
198
        }
2691
2692
595
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
595
        if ( options.disableTests == false ) {
2701
595
            tests::test(op, result.second);
2702
595
        }
2703
2704
595
        postprocess(module, op, result);
2705
595
    }
2706
2707
135
    if ( options.noCompare == false ) {
2708
123
        compare(operations, results, data, size);
2709
123
    }
2710
135
}
cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECRDSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
99
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
99
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
99
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
189
    do {
2596
189
        auto op = getOp(&parentDs, data, size);
2597
189
        auto module = getModule(parentDs);
2598
189
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
189
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
189
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
7
            break;
2607
7
        }
2608
189
    } while ( parentDs.Get<bool>() == true );
2609
2610
99
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
99
#if 1
2616
99
    {
2617
99
        std::set<uint64_t> moduleIDs;
2618
352
        for (const auto& m : modules ) {
2619
352
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
352
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
352
            moduleIDs.insert(moduleID);
2627
352
        }
2628
2629
99
        std::set<uint64_t> operationModuleIDs;
2630
172
        for (const auto& op : operations) {
2631
172
            operationModuleIDs.insert(op.first->ID);
2632
172
        }
2633
2634
99
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
99
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
99
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
264
        for (const auto& id : addModuleIDs) {
2639
264
            operations.push_back({ modules.at(id), operations[0].second});
2640
264
        }
2641
99
    }
2642
99
#endif
2643
2644
99
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
99
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
535
    for (size_t i = 0; i < operations.size(); i++) {
2652
436
        auto& operation = operations[i];
2653
2654
436
        auto& module = operation.first;
2655
436
        auto& op = operation.second;
2656
2657
436
        if ( i > 0 ) {
2658
348
            auto& prevModule = operations[i-1].first;
2659
348
            auto& prevOp = operations[i].second;
2660
2661
348
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
84
                auto& curModifier = op.modifier.GetVectorPtr();
2663
84
                if ( curModifier.size() == 0 ) {
2664
30.7k
                    for (size_t j = 0; j < 512; j++) {
2665
30.7k
                        curModifier.push_back(1);
2666
30.7k
                    }
2667
60
                } else {
2668
756
                    for (auto& c : curModifier) {
2669
756
                        c++;
2670
756
                    }
2671
24
                }
2672
84
            }
2673
348
        }
2674
2675
436
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
436
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
436
        const auto& result = results.back();
2682
2683
436
        if ( result.second != std::nullopt ) {
2684
61
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
61
        }
2691
2692
436
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
436
        if ( options.disableTests == false ) {
2701
436
            tests::test(op, result.second);
2702
436
        }
2703
2704
436
        postprocess(module, op, result);
2705
436
    }
2706
2707
99
    if ( options.noCompare == false ) {
2708
88
        compare(operations, results, data, size);
2709
88
    }
2710
99
}
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
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::DSA_Verify>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Signature, cryptofuzz::operation::DSA_Sign>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::DSA_Parameters, cryptofuzz::operation::DSA_GenerateParameters>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DSA_PrivateToPublic>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DSA_GenerateKeyPair>::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
2590
90
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
90
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
90
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
155
    do {
2596
155
        auto op = getOp(&parentDs, data, size);
2597
155
        auto module = getModule(parentDs);
2598
155
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
155
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
155
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
2
            break;
2607
2
        }
2608
155
    } while ( parentDs.Get<bool>() == true );
2609
2610
90
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
90
#if 1
2616
90
    {
2617
90
        std::set<uint64_t> moduleIDs;
2618
300
        for (const auto& m : modules ) {
2619
300
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
300
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
300
            moduleIDs.insert(moduleID);
2627
300
        }
2628
2629
90
        std::set<uint64_t> operationModuleIDs;
2630
126
        for (const auto& op : operations) {
2631
126
            operationModuleIDs.insert(op.first->ID);
2632
126
        }
2633
2634
90
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
90
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
90
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
225
        for (const auto& id : addModuleIDs) {
2639
225
            operations.push_back({ modules.at(id), operations[0].second});
2640
225
        }
2641
90
    }
2642
90
#endif
2643
2644
90
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
90
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
441
    for (size_t i = 0; i < operations.size(); i++) {
2652
351
        auto& operation = operations[i];
2653
2654
351
        auto& module = operation.first;
2655
351
        auto& op = operation.second;
2656
2657
351
        if ( i > 0 ) {
2658
276
            auto& prevModule = operations[i-1].first;
2659
276
            auto& prevOp = operations[i].second;
2660
2661
276
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
51
                auto& curModifier = op.modifier.GetVectorPtr();
2663
51
                if ( curModifier.size() == 0 ) {
2664
16.9k
                    for (size_t j = 0; j < 512; j++) {
2665
16.8k
                        curModifier.push_back(1);
2666
16.8k
                    }
2667
33
                } else {
2668
1.64k
                    for (auto& c : curModifier) {
2669
1.64k
                        c++;
2670
1.64k
                    }
2671
18
                }
2672
51
            }
2673
276
        }
2674
2675
351
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
351
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
351
        const auto& result = results.back();
2682
2683
351
        if ( result.second != std::nullopt ) {
2684
29
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
29
        }
2691
2692
351
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
351
        if ( options.disableTests == false ) {
2701
351
            tests::test(op, result.second);
2702
351
        }
2703
2704
351
        postprocess(module, op, result);
2705
351
    }
2706
2707
90
    if ( options.noCompare == false ) {
2708
75
        compare(operations, results, data, size);
2709
75
    }
2710
90
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::Ciphertext, cryptofuzz::operation::ECIES_Encrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Buffer, cryptofuzz::operation::ECIES_Decrypt>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Add>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
134
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
134
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
134
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
217
    do {
2596
217
        auto op = getOp(&parentDs, data, size);
2597
217
        auto module = getModule(parentDs);
2598
217
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
217
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
217
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
11
            break;
2607
11
        }
2608
217
    } while ( parentDs.Get<bool>() == true );
2609
2610
134
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
134
#if 1
2616
134
    {
2617
134
        std::set<uint64_t> moduleIDs;
2618
488
        for (const auto& m : modules ) {
2619
488
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
488
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
488
            moduleIDs.insert(moduleID);
2627
488
        }
2628
2629
134
        std::set<uint64_t> operationModuleIDs;
2630
189
        for (const auto& op : operations) {
2631
189
            operationModuleIDs.insert(op.first->ID);
2632
189
        }
2633
2634
134
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
134
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
134
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
366
        for (const auto& id : addModuleIDs) {
2639
366
            operations.push_back({ modules.at(id), operations[0].second});
2640
366
        }
2641
134
    }
2642
134
#endif
2643
2644
134
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
134
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
689
    for (size_t i = 0; i < operations.size(); i++) {
2652
555
        auto& operation = operations[i];
2653
2654
555
        auto& module = operation.first;
2655
555
        auto& op = operation.second;
2656
2657
555
        if ( i > 0 ) {
2658
433
            auto& prevModule = operations[i-1].first;
2659
433
            auto& prevOp = operations[i].second;
2660
2661
433
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
67
                auto& curModifier = op.modifier.GetVectorPtr();
2663
67
                if ( curModifier.size() == 0 ) {
2664
17.4k
                    for (size_t j = 0; j < 512; j++) {
2665
17.4k
                        curModifier.push_back(1);
2666
17.4k
                    }
2667
34
                } else {
2668
354
                    for (auto& c : curModifier) {
2669
354
                        c++;
2670
354
                    }
2671
33
                }
2672
67
            }
2673
433
        }
2674
2675
555
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
555
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
555
        const auto& result = results.back();
2682
2683
555
        if ( result.second != std::nullopt ) {
2684
20
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
20
        }
2691
2692
555
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
555
        if ( options.disableTests == false ) {
2701
555
            tests::test(op, result.second);
2702
555
        }
2703
2704
555
        postprocess(module, op, result);
2705
555
    }
2706
2707
134
    if ( options.noCompare == false ) {
2708
122
        compare(operations, results, data, size);
2709
122
    }
2710
134
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Mul>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
328
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
328
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
328
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
391
    do {
2596
391
        auto op = getOp(&parentDs, data, size);
2597
391
        auto module = getModule(parentDs);
2598
391
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
391
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
391
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
5
            break;
2607
5
        }
2608
391
    } while ( parentDs.Get<bool>() == true );
2609
2610
328
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
328
#if 1
2616
328
    {
2617
328
        std::set<uint64_t> moduleIDs;
2618
1.25k
        for (const auto& m : modules ) {
2619
1.25k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
1.25k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
1.25k
            moduleIDs.insert(moduleID);
2627
1.25k
        }
2628
2629
328
        std::set<uint64_t> operationModuleIDs;
2630
366
        for (const auto& op : operations) {
2631
366
            operationModuleIDs.insert(op.first->ID);
2632
366
        }
2633
2634
328
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
328
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
328
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
942
        for (const auto& id : addModuleIDs) {
2639
942
            operations.push_back({ modules.at(id), operations[0].second});
2640
942
        }
2641
328
    }
2642
328
#endif
2643
2644
328
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
328
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
1.63k
    for (size_t i = 0; i < operations.size(); i++) {
2652
1.30k
        auto& operation = operations[i];
2653
2654
1.30k
        auto& module = operation.first;
2655
1.30k
        auto& op = operation.second;
2656
2657
1.30k
        if ( i > 0 ) {
2658
994
            auto& prevModule = operations[i-1].first;
2659
994
            auto& prevOp = operations[i].second;
2660
2661
994
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
52
                auto& curModifier = op.modifier.GetVectorPtr();
2663
52
                if ( curModifier.size() == 0 ) {
2664
15.3k
                    for (size_t j = 0; j < 512; j++) {
2665
15.3k
                        curModifier.push_back(1);
2666
15.3k
                    }
2667
30
                } else {
2668
741
                    for (auto& c : curModifier) {
2669
741
                        c++;
2670
741
                    }
2671
22
                }
2672
52
            }
2673
994
        }
2674
2675
1.30k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
1.30k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
1.30k
        const auto& result = results.back();
2682
2683
1.30k
        if ( result.second != std::nullopt ) {
2684
187
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
187
        }
2691
2692
1.30k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
1.30k
        if ( options.disableTests == false ) {
2701
1.30k
            tests::test(op, result.second);
2702
1.30k
        }
2703
2704
1.30k
        postprocess(module, op, result);
2705
1.30k
    }
2706
2707
328
    if ( options.noCompare == false ) {
2708
314
        compare(operations, results, data, size);
2709
314
    }
2710
328
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Neg>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
98
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
98
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
98
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
148
    do {
2596
148
        auto op = getOp(&parentDs, data, size);
2597
148
        auto module = getModule(parentDs);
2598
148
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
148
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
148
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
3
            break;
2607
3
        }
2608
148
    } while ( parentDs.Get<bool>() == true );
2609
2610
98
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
98
#if 1
2616
98
    {
2617
98
        std::set<uint64_t> moduleIDs;
2618
344
        for (const auto& m : modules ) {
2619
344
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
344
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
344
            moduleIDs.insert(moduleID);
2627
344
        }
2628
2629
98
        std::set<uint64_t> operationModuleIDs;
2630
126
        for (const auto& op : operations) {
2631
126
            operationModuleIDs.insert(op.first->ID);
2632
126
        }
2633
2634
98
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
98
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
98
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
258
        for (const auto& id : addModuleIDs) {
2639
258
            operations.push_back({ modules.at(id), operations[0].second});
2640
258
        }
2641
98
    }
2642
98
#endif
2643
2644
98
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
98
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
482
    for (size_t i = 0; i < operations.size(); i++) {
2652
384
        auto& operation = operations[i];
2653
2654
384
        auto& module = operation.first;
2655
384
        auto& op = operation.second;
2656
2657
384
        if ( i > 0 ) {
2658
298
            auto& prevModule = operations[i-1].first;
2659
298
            auto& prevOp = operations[i].second;
2660
2661
298
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
40
                auto& curModifier = op.modifier.GetVectorPtr();
2663
40
                if ( curModifier.size() == 0 ) {
2664
9.74k
                    for (size_t j = 0; j < 512; j++) {
2665
9.72k
                        curModifier.push_back(1);
2666
9.72k
                    }
2667
21
                } else {
2668
704
                    for (auto& c : curModifier) {
2669
704
                        c++;
2670
704
                    }
2671
21
                }
2672
40
            }
2673
298
        }
2674
2675
384
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
384
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
384
        const auto& result = results.back();
2682
2683
384
        if ( result.second != std::nullopt ) {
2684
29
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
29
        }
2691
2692
384
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
384
        if ( options.disableTests == false ) {
2701
384
            tests::test(op, result.second);
2702
384
        }
2703
2704
384
        postprocess(module, op, result);
2705
384
    }
2706
2707
98
    if ( options.noCompare == false ) {
2708
86
        compare(operations, results, data, size);
2709
86
    }
2710
98
}
cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::ECC_Point_Dbl>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
283
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
283
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
283
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
375
    do {
2596
375
        auto op = getOp(&parentDs, data, size);
2597
375
        auto module = getModule(parentDs);
2598
375
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
375
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
375
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
13
            break;
2607
13
        }
2608
375
    } while ( parentDs.Get<bool>() == true );
2609
2610
283
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
283
#if 1
2616
283
    {
2617
283
        std::set<uint64_t> moduleIDs;
2618
1.06k
        for (const auto& m : modules ) {
2619
1.06k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
1.06k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
1.06k
            moduleIDs.insert(moduleID);
2627
1.06k
        }
2628
2629
283
        std::set<uint64_t> operationModuleIDs;
2630
346
        for (const auto& op : operations) {
2631
346
            operationModuleIDs.insert(op.first->ID);
2632
346
        }
2633
2634
283
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
283
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
283
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
801
        for (const auto& id : addModuleIDs) {
2639
801
            operations.push_back({ modules.at(id), operations[0].second});
2640
801
        }
2641
283
    }
2642
283
#endif
2643
2644
283
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
283
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
1.43k
    for (size_t i = 0; i < operations.size(); i++) {
2652
1.14k
        auto& operation = operations[i];
2653
2654
1.14k
        auto& module = operation.first;
2655
1.14k
        auto& op = operation.second;
2656
2657
1.14k
        if ( i > 0 ) {
2658
880
            auto& prevModule = operations[i-1].first;
2659
880
            auto& prevOp = operations[i].second;
2660
2661
880
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
79
                auto& curModifier = op.modifier.GetVectorPtr();
2663
79
                if ( curModifier.size() == 0 ) {
2664
24.6k
                    for (size_t j = 0; j < 512; j++) {
2665
24.5k
                        curModifier.push_back(1);
2666
24.5k
                    }
2667
48
                } else {
2668
217
                    for (auto& c : curModifier) {
2669
217
                        c++;
2670
217
                    }
2671
31
                }
2672
79
            }
2673
880
        }
2674
2675
1.14k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
1.14k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
1.14k
        const auto& result = results.back();
2682
2683
1.14k
        if ( result.second != std::nullopt ) {
2684
72
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
72
        }
2691
2692
1.14k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
1.14k
        if ( options.disableTests == false ) {
2701
1.14k
            tests::test(op, result.second);
2702
1.14k
        }
2703
2704
1.14k
        postprocess(module, op, result);
2705
1.14k
    }
2706
2707
283
    if ( options.noCompare == false ) {
2708
267
        compare(operations, results, data, size);
2709
267
    }
2710
283
}
Unexecuted instantiation: cryptofuzz::ExecutorBase<bool, cryptofuzz::operation::ECC_Point_Cmp>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::component::BignumPair, cryptofuzz::operation::DH_GenerateKeyPair>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Unexecuted instantiation: cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::DH_Derive>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
cryptofuzz::ExecutorBase<cryptofuzz::Bignum, cryptofuzz::operation::BignumCalc>::Run(fuzzing::datasource::Datasource&, unsigned char const*, unsigned long) const
Line
Count
Source
2590
4.44k
void ExecutorBase<ResultType, OperationType>::Run(Datasource& parentDs, const uint8_t* data, const size_t size) const {
2591
4.44k
    typename ExecutorBase<ResultType, OperationType>::ResultSet results;
2592
2593
4.44k
    std::vector< std::pair<std::shared_ptr<Module>, OperationType> > operations;
2594
2595
4.87k
    do {
2596
4.87k
        auto op = getOp(&parentDs, data, size);
2597
4.87k
        auto module = getModule(parentDs);
2598
4.87k
        if ( module == nullptr ) {
2599
0
            continue;
2600
0
        }
2601
2602
4.87k
        operations.push_back( {module, op} );
2603
2604
        /* Limit number of operations per run to prevent time-outs */
2605
4.87k
        if ( operations.size() == OperationType::MaxOperations() ) {
2606
37
            break;
2607
37
        }
2608
4.87k
    } while ( parentDs.Get<bool>() == true );
2609
2610
4.44k
    if ( operations.empty() == true ) {
2611
0
        return;
2612
0
    }
2613
2614
    /* Enable this to run every operation on every loaded module */
2615
4.44k
#if 1
2616
4.44k
    {
2617
4.44k
        std::set<uint64_t> moduleIDs;
2618
17.7k
        for (const auto& m : modules ) {
2619
17.7k
            const auto moduleID = m.first;
2620
2621
            /* Skip if this is a disabled module */
2622
17.7k
            if ( options.disableModules.HaveExplicit(moduleID) ) {
2623
0
                continue;
2624
0
            }
2625
2626
17.7k
            moduleIDs.insert(moduleID);
2627
17.7k
        }
2628
2629
4.44k
        std::set<uint64_t> operationModuleIDs;
2630
4.84k
        for (const auto& op : operations) {
2631
4.84k
            operationModuleIDs.insert(op.first->ID);
2632
4.84k
        }
2633
2634
4.44k
        std::vector<uint64_t> addModuleIDs(moduleIDs.size());
2635
4.44k
        auto it = std::set_difference(moduleIDs.begin(), moduleIDs.end(), operationModuleIDs.begin(), operationModuleIDs.end(), addModuleIDs.begin());
2636
4.44k
        addModuleIDs.resize(it - addModuleIDs.begin());
2637
2638
13.2k
        for (const auto& id : addModuleIDs) {
2639
13.2k
            operations.push_back({ modules.at(id), operations[0].second});
2640
13.2k
        }
2641
4.44k
    }
2642
4.44k
#endif
2643
2644
4.44k
    if ( operations.size() < options.minModules ) {
2645
0
        return;
2646
0
    }
2647
2648
4.44k
    if ( options.debug == true && !operations.empty() ) {
2649
0
        printf("Running:\n%s\n", operations[0].second.ToString().c_str());
2650
0
    }
2651
22.5k
    for (size_t i = 0; i < operations.size(); i++) {
2652
18.1k
        auto& operation = operations[i];
2653
2654
18.1k
        auto& module = operation.first;
2655
18.1k
        auto& op = operation.second;
2656
2657
18.1k
        if ( i > 0 ) {
2658
13.7k
            auto& prevModule = operations[i-1].first;
2659
13.7k
            auto& prevOp = operations[i].second;
2660
2661
13.7k
            if ( prevModule == module && prevOp.modifier == op.modifier ) {
2662
412
                auto& curModifier = op.modifier.GetVectorPtr();
2663
412
                if ( curModifier.size() == 0 ) {
2664
132k
                    for (size_t j = 0; j < 512; j++) {
2665
132k
                        curModifier.push_back(1);
2666
132k
                    }
2667
259
                } else {
2668
4.61k
                    for (auto& c : curModifier) {
2669
4.61k
                        c++;
2670
4.61k
                    }
2671
153
                }
2672
412
            }
2673
13.7k
        }
2674
2675
18.1k
        if ( options.debug == true ) {
2676
0
            printf("modifier: %s\n", util::HexDump(op.modifier.Get()).c_str());
2677
0
        }
2678
2679
18.1k
        results.push_back( {module, std::move(callModule(module, op))} );
2680
2681
18.1k
        const auto& result = results.back();
2682
2683
18.1k
        if ( result.second != std::nullopt ) {
2684
12.5k
            if ( options.jsonDumpFP != std::nullopt ) {
2685
0
                nlohmann::json j;
2686
0
                j["operation"] = op.ToJSON();
2687
0
                j["result"] = util::ToJSON(*result.second);
2688
0
                fprintf(*options.jsonDumpFP, "%s\n", j.dump().c_str());
2689
0
            }
2690
12.5k
        }
2691
2692
18.1k
        if ( options.debug == true ) {
2693
0
            printf("Module %s result:\n\n%s\n\n",
2694
0
                    result.first->name.c_str(),
2695
0
                    result.second == std::nullopt ?
2696
0
                        "(empty)" :
2697
0
                        util::ToString(*result.second).c_str());
2698
0
        }
2699
2700
18.1k
        if ( options.disableTests == false ) {
2701
18.1k
            tests::test(op, result.second);
2702
18.1k
        }
2703
2704
18.1k
        postprocess(module, op, result);
2705
18.1k
    }
2706
2707
4.44k
    if ( options.noCompare == false ) {
2708
4.43k
        compare(operations, results, data, size);
2709
4.43k
    }
2710
4.44k
}
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
2711
2712
/* Explicit template instantiation */
2713
template class ExecutorBase<component::Digest, operation::Digest>;
2714
template class ExecutorBase<component::MAC, operation::HMAC>;
2715
template class ExecutorBase<component::MAC, operation::UMAC>;
2716
template class ExecutorBase<component::MAC, operation::CMAC>;
2717
template class ExecutorBase<component::Ciphertext, operation::SymmetricEncrypt>;
2718
template class ExecutorBase<component::Cleartext, operation::SymmetricDecrypt>;
2719
template class ExecutorBase<component::Key, operation::KDF_SCRYPT>;
2720
template class ExecutorBase<component::Key, operation::KDF_HKDF>;
2721
template class ExecutorBase<component::Key, operation::KDF_TLS1_PRF>;
2722
template class ExecutorBase<component::Key, operation::KDF_PBKDF>;
2723
template class ExecutorBase<component::Key, operation::KDF_PBKDF1>;
2724
template class ExecutorBase<component::Key, operation::KDF_PBKDF2>;
2725
template class ExecutorBase<component::Key, operation::KDF_ARGON2>;
2726
template class ExecutorBase<component::Key, operation::KDF_SSH>;
2727
template class ExecutorBase<component::Key, operation::KDF_X963>;
2728
template class ExecutorBase<component::Key, operation::KDF_BCRYPT>;
2729
template class ExecutorBase<component::Key, operation::KDF_SP_800_108>;
2730
template class ExecutorBase<component::ECC_PublicKey, operation::ECC_PrivateToPublic>;
2731
template class ExecutorBase<bool, operation::ECC_ValidatePubkey>;
2732
template class ExecutorBase<component::ECC_KeyPair, operation::ECC_GenerateKeyPair>;
2733
template class ExecutorBase<component::ECCSI_Signature, operation::ECCSI_Sign>;
2734
template class ExecutorBase<component::ECDSA_Signature, operation::ECDSA_Sign>;
2735
template class ExecutorBase<component::ECGDSA_Signature, operation::ECGDSA_Sign>;
2736
template class ExecutorBase<component::ECRDSA_Signature, operation::ECRDSA_Sign>;
2737
template class ExecutorBase<component::Schnorr_Signature, operation::Schnorr_Sign>;
2738
template class ExecutorBase<bool, operation::ECCSI_Verify>;
2739
template class ExecutorBase<bool, operation::ECDSA_Verify>;
2740
template class ExecutorBase<bool, operation::ECGDSA_Verify>;
2741
template class ExecutorBase<bool, operation::ECRDSA_Verify>;
2742
template class ExecutorBase<bool, operation::Schnorr_Verify>;
2743
template class ExecutorBase<component::ECC_PublicKey, operation::ECDSA_Recover>;
2744
template class ExecutorBase<bool, operation::DSA_Verify>;
2745
template class ExecutorBase<component::DSA_Signature, operation::DSA_Sign>;
2746
template class ExecutorBase<component::DSA_Parameters, operation::DSA_GenerateParameters>;
2747
template class ExecutorBase<component::Bignum, operation::DSA_PrivateToPublic>;
2748
template class ExecutorBase<component::DSA_KeyPair, operation::DSA_GenerateKeyPair>;
2749
template class ExecutorBase<component::Secret, operation::ECDH_Derive>;
2750
template class ExecutorBase<component::Ciphertext, operation::ECIES_Encrypt>;
2751
template class ExecutorBase<component::Cleartext, operation::ECIES_Decrypt>;
2752
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Add>;
2753
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Mul>;
2754
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Neg>;
2755
template class ExecutorBase<component::ECC_Point, operation::ECC_Point_Dbl>;
2756
template class ExecutorBase<bool, operation::ECC_Point_Cmp>;
2757
template class ExecutorBase<component::DH_KeyPair, operation::DH_GenerateKeyPair>;
2758
template class ExecutorBase<component::Bignum, operation::DH_Derive>;
2759
template class ExecutorBase<component::Bignum, operation::BignumCalc>;
2760
template class ExecutorBase<component::Fp2, operation::BignumCalc_Fp2>;
2761
template class ExecutorBase<component::Fp12, operation::BignumCalc_Fp12>;
2762
template class ExecutorBase<component::BLS_PublicKey, operation::BLS_PrivateToPublic>;
2763
template class ExecutorBase<component::G2, operation::BLS_PrivateToPublic_G2>;
2764
template class ExecutorBase<component::BLS_Signature, operation::BLS_Sign>;
2765
template class ExecutorBase<bool, operation::BLS_Verify>;
2766
template class ExecutorBase<component::BLS_BatchSignature, operation::BLS_BatchSign>;
2767
template class ExecutorBase<bool, operation::BLS_BatchVerify>;
2768
template class ExecutorBase<component::G1, operation::BLS_Aggregate_G1>;
2769
template class ExecutorBase<component::G2, operation::BLS_Aggregate_G2>;
2770
template class ExecutorBase<component::Fp12, operation::BLS_Pairing>;
2771
template class ExecutorBase<component::Fp12, operation::BLS_MillerLoop>;
2772
template class ExecutorBase<component::Fp12, operation::BLS_FinalExp>;
2773
template class ExecutorBase<component::G1, operation::BLS_HashToG1>;
2774
template class ExecutorBase<component::G2, operation::BLS_HashToG2>;
2775
template class ExecutorBase<component::G1, operation::BLS_MapToG1>;
2776
template class ExecutorBase<component::G2, operation::BLS_MapToG2>;
2777
template class ExecutorBase<bool, operation::BLS_IsG1OnCurve>;
2778
template class ExecutorBase<bool, operation::BLS_IsG2OnCurve>;
2779
template class ExecutorBase<component::BLS_KeyPair, operation::BLS_GenerateKeyPair>;
2780
template class ExecutorBase<component::G1, operation::BLS_Decompress_G1>;
2781
template class ExecutorBase<component::Bignum, operation::BLS_Compress_G1>;
2782
template class ExecutorBase<component::G2, operation::BLS_Decompress_G2>;
2783
template class ExecutorBase<component::G1, operation::BLS_Compress_G2>;
2784
template class ExecutorBase<component::G1, operation::BLS_G1_Add>;
2785
template class ExecutorBase<component::G1, operation::BLS_G1_Mul>;
2786
template class ExecutorBase<bool, operation::BLS_G1_IsEq>;
2787
template class ExecutorBase<component::G1, operation::BLS_G1_Neg>;
2788
template class ExecutorBase<component::G2, operation::BLS_G2_Add>;
2789
template class ExecutorBase<component::G2, operation::BLS_G2_Mul>;
2790
template class ExecutorBase<bool, operation::BLS_G2_IsEq>;
2791
template class ExecutorBase<component::G2, operation::BLS_G2_Neg>;
2792
template class ExecutorBase<Buffer, operation::Misc>;
2793
template class ExecutorBase<bool, operation::SR25519_Verify>;
2794
2795
} /* namespace cryptofuzz */