Coverage Report

Created: 2026-11-15 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/nss/cryptofuzz/modules/botan/bn_ops.cpp
Line
Count
Source
1
#include <cryptofuzz/util.h>
2
#include <cryptofuzz/repository.h>
3
#include <fuzzing/datasource/id.hpp>
4
#include <botan/numthry.h>
5
#include <botan/reducer.h>
6
#include <botan/internal/divide.h>
7
#include <botan/internal/barrett.h>
8
#include <botan/internal/primality.h>
9
#include <botan/system_rng.h>
10
11
#include "bn_ops.h"
12
13
namespace cryptofuzz {
14
namespace module {
15
namespace Botan_bignum {
16
17
namespace detail {
18
75
    std::optional<size_t> To_size_t(const Bignum& bn) {
19
        /* TODO use #if */
20
21
75
        if ( sizeof(size_t) == 4 ) {
22
0
            try {
23
0
                return bn.ConstRef().to_u32bit();
24
0
            } catch ( ::Botan::Encoding_Error ) {
25
0
                return std::nullopt;
26
0
            }
27
75
        } else if ( sizeof(size_t) == 8 ) {
28
75
            if( bn.ConstRef().is_negative() ) {
29
0
                return std::nullopt;
30
0
            }
31
32
75
            if( bn.ConstRef().bits() > 64 ) {
33
5
                return std::nullopt;
34
5
            }
35
36
70
            uint64_t out = 0;
37
38
630
            for (size_t i = 0; i != 8; ++i) {
39
560
                out = (out << 8) | bn.ConstRef().byte_at(7-i);
40
560
            }
41
42
70
            return out;
43
75
        } else {
44
0
            CF_UNREACHABLE();
45
0
        }
46
75
    }
47
}
48
49
#if !defined(CRYPTOFUZZ_BOTAN_IS_ORACLE)
50
179
 #define GET_UINT8_FOR_SWITCH() ds.Get<uint8_t>()
51
#else
52
 #define GET_UINT8_FOR_SWITCH() 0
53
#endif /* CRYPTOFUZZ_BOTAN_IS_ORACLE */
54
55
250
#define APPLY_MODULO if (modulo != std::nullopt) res = (res.ConstRef() % modulo->ConstRef())
56
57
15
bool Add::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
58
15
    (void)ds;
59
60
15
    res = bn[0].Ref() + bn[1].Ref();
61
62
15
    APPLY_MODULO;
63
64
15
    return true;
65
15
}
66
67
35
bool Sub::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
68
35
    (void)ds;
69
70
35
    res = bn[0].Ref() - bn[1].Ref();
71
72
35
    APPLY_MODULO;
73
74
35
    return true;
75
35
}
76
77
41
bool Mul::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
78
41
    (void)ds;
79
80
41
    res = bn[0].Ref() * bn[1].Ref();
81
82
41
    APPLY_MODULO;
83
84
41
    return true;
85
41
}
86
87
43
bool Div::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
88
43
    (void)modulo;
89
43
    (void)ds;
90
91
    /* Botan handles negative division different than
92
     * other libraries.
93
     */
94
43
    CF_CHECK_TRUE(bn[0].Ref() > 0);
95
42
    CF_CHECK_TRUE(bn[1].Ref() > 0);
96
97
41
    try {
98
41
        switch ( GET_UINT8_FOR_SWITCH() ) {
99
3
            case    0:
100
                /* / operator */
101
3
                res = bn[0].Ref() / bn[1].Ref();
102
3
                return true;
103
3
            case    1:
104
3
                {
105
3
                    CF_CHECK_TRUE(bn[1].Ref() != 0);
106
3
                    Bignum dummy;
107
3
                    /* noret */ ::Botan::vartime_divide(bn[0].Ref(), bn[1].Ref(), res.Ref(), dummy.Ref());
108
3
                }
109
0
                return true;
110
3
            case    2:
111
3
                {
112
3
                    CF_CHECK_GT(bn[1].Ref(), 0);
113
3
                    CF_CHECK_TRUE(bn[1].Ref() < 256);
114
2
                    ::Botan::word dummy;
115
2
                    CF_NORET(::Botan::ct_divide_word(bn[0].Ref(), bn[1].Ref().word_at(0), res.Ref(), dummy));
116
2
                }
117
0
                return true;
118
9
            case    3:
119
9
                CF_CHECK_TRUE(bn[1].Ref() != 0);
120
9
                res = ::Botan::ct_divide(bn[0].Ref(), bn[1].Ref());
121
9
                return true;
122
5
            case    4:
123
                /* /= operator */
124
5
                res = bn[0].Ref();
125
5
                res.Ref() /= bn[1].Ref();
126
5
                return true;
127
41
        }
128
41
    } catch ( fuzzing::datasource::Datasource::OutOfData ) {
129
12
        return false;
130
12
    } catch ( ::Botan::Invalid_Argument& e ) {
131
        /* Botan is expected to throw an exception when divisor is 0 */
132
0
        if ( bn[1].Ref() == 0 ) {
133
0
            return false;
134
0
        }
135
136
        /* Rethrow */
137
0
        throw e;
138
0
    }
139
140
9
end:
141
9
    return false;
142
41
}
143
144
32
bool Mod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
145
32
    (void)modulo;
146
32
    (void)ds;
147
148
32
    try {
149
32
        switch ( GET_UINT8_FOR_SWITCH() ) {
150
3
            case    0:
151
3
                {
152
3
                    try {
153
3
                        const Botan::Modular_Reducer reducer(bn[1].Ref());
154
3
                        res = reducer.reduce(bn[0].Ref());
155
3
                    } catch ( ::Botan::Invalid_State& e ) {
156
                        /* Modular reducer is expected to throw an exception when modulo is 0 */
157
0
                        if ( bn[1].Ref() == 0 ) {
158
0
                            return false;
159
0
                        }
160
161
                        /* Rethrow */
162
0
                        throw e;
163
0
                    }
164
3
                }
165
2
                return true;
166
2
            case    1:
167
2
                res = ct_modulo(bn[0].Ref(), bn[1].Ref());
168
2
                return true;
169
2
            case    2:
170
                /* % operator */
171
2
                res = bn[0].Ref() % bn[1].Ref();
172
2
                return true;
173
15
            case    3:
174
                /* %= operator */
175
15
                {
176
15
                    res = bn[0].Ref();
177
178
15
                    const ::Botan::word modulo = bn[1].Ref().word_at(0);
179
180
                    /* Ensure no truncation occurred */
181
15
                    if ( modulo != bn[1].Ref() ) {
182
1
                        return false;
183
1
                    }
184
185
14
                    res = bn[0].Ref() %= modulo;
186
14
                }
187
0
                return true;
188
32
        }
189
32
    } catch ( fuzzing::datasource::Datasource::OutOfData ) {
190
8
        return false;
191
8
    } catch ( ::Botan::Invalid_Argument& e ) {
192
        /* Botan is expected to throw an exception when modulo is <= 0 */
193
4
        if ( bn[1].Ref() <= 0 ) {
194
4
            return false;
195
4
        }
196
197
        /* Rethrow */
198
0
        throw e;
199
4
    }
200
201
2
    return false;
202
32
}
203
204
39
bool Exp::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
205
39
    (void)ds;
206
207
39
    if ( modulo == std::nullopt ) {
208
27
        return false;
209
27
    }
210
211
12
    res = ::Botan::power_mod(bn[0].Ref(), bn[1].Ref(), modulo->ConstRef());
212
213
12
    return true;
214
39
}
215
216
320
bool ExpMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
217
320
    (void)modulo;
218
320
    (void)ds;
219
220
    /* Exponent and modulus must be positive, according to the documentation */
221
320
    if ( bn[1].Ref() < 0 || bn[2].Ref() <= 0 ) {
222
7
        return false;
223
7
    }
224
225
313
    res = ::Botan::power_mod(bn[0].Ref(), bn[1].Ref(), bn[2].Ref());
226
227
313
    return true;
228
320
}
229
230
66
bool Sqr::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
231
66
    (void)ds;
232
233
66
    res = ::Botan::square(bn[0].Ref());
234
235
66
    APPLY_MODULO;
236
237
66
    return true;
238
66
}
239
240
61
bool GCD::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
241
61
    (void)modulo;
242
61
    (void)ds;
243
244
61
    res = ::Botan::gcd(bn[0].Ref(), bn[1].Ref());
245
246
61
    return true;
247
61
}
248
249
34
bool SqrMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
250
34
    (void)modulo;
251
34
    (void)ds;
252
253
34
    if ( bn[1].Ref().is_negative() ) {
254
0
        return false;
255
34
    } else {
256
34
        try {
257
34
            switch ( GET_UINT8_FOR_SWITCH() ) {
258
6
                case    0:
259
6
                    {
260
6
                        try {
261
6
                            ::Botan::Modular_Reducer mod(bn[1].Ref());
262
6
                            res = mod.square(bn[0].Ref());
263
6
                        } catch ( ::Botan::Invalid_State& e ) {
264
                            /* Modular reducer is expected to throw an exception when modulo is 0 */
265
0
                            if ( bn[1].Ref() == 0 ) {
266
0
                                return false;
267
0
                            }
268
269
                            /* Rethrow */
270
0
                            throw e;
271
0
                        }
272
6
                    }
273
5
                    break;
274
2
                case    1:
275
2
                    res = ::Botan::square(bn[0].Ref()) % bn[1].Ref();
276
2
                    break;
277
7
                default:
278
7
                    return false;
279
34
            }
280
34
        } catch ( fuzzing::datasource::Datasource::OutOfData ) {
281
19
            return false;
282
19
        } catch ( ::Botan::Invalid_Argument& e ) {
283
            /* Botan is expected to throw an exception when modulo is 0 */
284
2
            if ( bn[1].Ref() == 0 ) {
285
2
                return false;
286
2
            }
287
288
            /* Rethrow */
289
0
            throw e;
290
2
        }
291
34
    }
292
293
6
    return true;
294
34
}
295
296
336
bool InvMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
297
336
    (void)modulo;
298
336
    (void)ds;
299
300
336
    const auto mod = modulo == std::nullopt ? bn[1].ConstRef() : modulo->ConstRef();
301
302
336
    try {
303
336
        res = ::Botan::inverse_mod(bn[0].Ref(), mod);
304
336
    } catch ( ::Botan::Invalid_Argument& e ) {
305
        /* inverse_mod() is expected to throw an exception when modulo is 0 */
306
14
        if ( mod == 0 ) {
307
14
            return false;
308
14
        }
309
310
        /* inverse_mod() is expected to throw an exception when either argument is negative */
311
0
        if ( bn[0].Ref() < 0 || mod < 0 ) {
312
0
            return false;
313
0
        }
314
315
        /* Rethrow */
316
0
        throw e;
317
0
    }
318
319
322
    return true;
320
336
}
321
322
19
bool Cmp::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
323
19
    (void)modulo;
324
19
    (void)ds;
325
326
19
    if ( bn[0].Ref() < bn[1].Ref() ) {
327
10
        res = Bignum("-1");
328
10
    } else if ( bn[0].Ref() > bn[1].Ref() ) {
329
5
        res = 1;
330
5
    } else {
331
4
        res = 0;
332
4
    }
333
334
19
    return true;
335
19
}
336
337
277
bool LCM::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
338
277
    (void)modulo;
339
277
    (void)ds;
340
341
277
    try {
342
277
        res = ::Botan::lcm(bn[0].Ref(), bn[1].Ref());
343
277
    } catch ( ::Botan::Invalid_Argument& e ) {
344
        /* lcm() is expected to throw in these cases */
345
0
        if ( bn[0].Ref() == 0 || bn[1].Ref() == 0 ) {
346
0
            return false;
347
0
        }
348
349
        /* Rethrow */
350
0
        throw e;
351
0
    }
352
353
354
277
    return true;
355
277
}
356
357
8
bool Abs::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
358
8
    (void)modulo;
359
8
    (void)ds;
360
361
8
    res = ::Botan::abs(bn[0].Ref());
362
363
8
    return true;
364
8
}
365
366
25
bool Jacobi::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
367
25
    (void)modulo;
368
25
    (void)ds;
369
370
371
25
    int resInt;
372
373
25
    try {
374
25
        resInt = ::Botan::jacobi(bn[0].Ref(), bn[1].Ref());
375
25
    } catch ( ::Botan::Invalid_Argument& e ) {
376
        /* jacobi() is expected to throw in these cases */
377
4
        if ( (bn[1].Ref() % 2) == 0 || bn[1].Ref() <= 1 ) {
378
4
            return false;
379
4
        }
380
381
        /* Rethrow */
382
0
        throw e;
383
4
    }
384
385
21
    if ( resInt == -1 ) {
386
5
        res = Bignum("-1");
387
16
    } else {
388
16
        res = resInt;
389
16
    }
390
391
21
    return true;
392
25
}
393
394
29
bool Neg::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
395
29
    (void)modulo;
396
29
    (void)ds;
397
398
29
    res = -bn[0].Ref();
399
400
29
    return true;
401
29
}
402
403
79
bool IsPrime::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
404
79
    (void)modulo;
405
79
    (void)ds;
406
407
79
    if ( bn[0].Ref().is_negative() ) {
408
0
        return false;
409
0
    }
410
411
    /* Avoid time-outs */
412
79
    if ( bn[0].Ref().bytes() > 300 ) {
413
1
        return false;
414
1
    }
415
416
78
    auto mod_n = Botan::Barrett_Reduction::for_public_modulus(bn[0].Ref());
417
78
    if ( Botan::is_bailie_psw_probable_prime(bn[0].Ref(), mod_n) ) {
418
19
        res = 1;
419
59
    } else {
420
59
        res = 0;
421
59
    }
422
423
78
    return true;
424
79
}
425
426
41
bool RShift::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
427
41
    (void)ds;
428
429
41
    const auto count = detail::To_size_t(bn[1].Ref());
430
431
41
    if ( count == std::nullopt ) {
432
3
        return false;
433
3
    }
434
435
38
    Bignum toShift = bn[0];
436
38
    if ( modulo && bn[0].Ref() % 2 ) {
437
13
        toShift = toShift.Ref() + modulo->ConstRef();
438
13
    }
439
440
38
    res = toShift.Ref() >> *count;
441
442
38
    APPLY_MODULO;
443
444
38
    return true;
445
41
}
446
447
13
bool LShift1::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
448
13
    (void)ds;
449
450
13
    res = bn[0].Ref() << 1;
451
452
13
    APPLY_MODULO;
453
454
13
    return true;
455
13
}
456
457
2
bool IsNeg::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
458
2
    (void)modulo;
459
2
    (void)ds;
460
461
2
    res = bn[0].Ref() < 0 ? 1 : 0;
462
463
2
    return true;
464
2
}
465
466
19
bool IsEq::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
467
19
    (void)ds;
468
469
19
    auto A = modulo == std::nullopt ? bn[0] : bn[0].Ref() % modulo->ConstRef();
470
19
    auto B = modulo == std::nullopt ? bn[1] : bn[1].Ref() % modulo->ConstRef();
471
472
19
    res = A.Ref() == B.Ref() ? 1 : 0;
473
474
19
    return true;
475
19
}
476
477
4
bool IsGt::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
478
4
    (void)modulo;
479
4
    (void)ds;
480
481
4
    res = bn[0].Ref() > bn[1].Ref() ? 1 : 0;
482
483
4
    return true;
484
4
}
485
486
2
bool IsGte::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
487
2
    (void)modulo;
488
2
    (void)ds;
489
490
2
    res = bn[0].Ref() >= bn[1].Ref() ? 1 : 0;
491
492
2
    return true;
493
2
}
494
495
3
bool IsLt::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
496
3
    (void)modulo;
497
3
    (void)ds;
498
499
3
    res = bn[0].Ref() < bn[1].Ref() ? 1 : 0;
500
501
3
    return true;
502
3
}
503
504
2
bool IsLte::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
505
2
    (void)modulo;
506
2
    (void)ds;
507
508
2
    res = bn[0].Ref() <= bn[1].Ref() ? 1 : 0;
509
510
2
    return true;
511
2
}
512
513
9
bool IsEven::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
514
9
    (void)modulo;
515
9
    (void)ds;
516
517
9
    res = !(bn[0].Ref() % 2) ? 1 : 0;
518
519
9
    return true;
520
9
}
521
522
5
bool IsOdd::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
523
5
    (void)modulo;
524
5
    (void)ds;
525
526
5
    res = (bn[0].Ref() % 2) ? 1 : 0;
527
528
5
    return true;
529
5
}
530
531
6
bool IsZero::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
532
6
    (void)ds;
533
534
6
    auto A = modulo == std::nullopt ? bn[0] : bn[0].Ref() % modulo->ConstRef();
535
536
6
    res = A.Ref() == 0 ? 1 : 0;
537
538
6
    return true;
539
6
}
540
541
1
bool IsNotZero::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
542
1
    (void)modulo;
543
1
    (void)ds;
544
545
1
    res = bn[0].Ref() == 0 ? 0 : 1;
546
547
1
    return true;
548
1
}
549
550
3
bool IsOne::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
551
3
    (void)ds;
552
553
3
    auto A = modulo == std::nullopt ? bn[0] : bn[0].Ref() % modulo->ConstRef();
554
555
3
    res = A.Ref() == 1 ? 1 : 0;
556
557
3
    return true;
558
3
}
559
560
20
bool MulMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
561
20
    (void)modulo;
562
20
    (void)ds;
563
564
20
    try {
565
20
        switch ( GET_UINT8_FOR_SWITCH() ) {
566
4
            case    0:
567
4
                {
568
4
                    try {
569
4
                        ::Botan::Modular_Reducer mod(bn[2].Ref());
570
4
                        res = mod.multiply(bn[0].Ref(), bn[1].Ref());
571
4
                    } catch ( ::Botan::Invalid_State& e ) {
572
                        /* Modular reducer is expected to throw an exception when modulo is 0 */
573
0
                        if ( bn[2].Ref() == 0 ) {
574
0
                            return false;
575
0
                        }
576
577
                        /* Rethrow */
578
0
                        throw e;
579
0
                    }
580
4
                }
581
3
                break;
582
2
            case    1:
583
2
                res = (bn[0].Ref() * bn[1].Ref()) % bn[2].Ref();
584
2
                break;
585
7
            default:
586
7
                return false;
587
20
        }
588
20
    } catch ( fuzzing::datasource::Datasource::OutOfData ) {
589
7
        return false;
590
7
    } catch ( ::Botan::Invalid_Argument& e ) {
591
        /* Botan is expected to throw an exception when modulo is <= 0 */
592
2
        if ( bn[2].Ref() <= 0 ) {
593
2
            return false;
594
2
        }
595
596
        /* Rethrow */
597
0
        throw e;
598
2
    }
599
600
4
    return true;
601
20
}
602
603
25
bool Bit::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
604
25
    (void)modulo;
605
25
    (void)ds;
606
607
25
    const auto pos = detail::To_size_t(bn[1].Ref());
608
609
25
    if ( pos == std::nullopt ) {
610
1
        return false;
611
1
    }
612
613
24
    res = bn[0].Ref().get_bit(*pos) ? 1 : 0;
614
615
24
    return true;
616
25
}
617
618
4
bool CmpAbs::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
619
4
    (void)modulo;
620
4
    std::vector<Bignum> bnAbs = {bn[0].Ref().abs(), bn[1].Ref().abs()};
621
4
    auto cmp = std::make_unique<Cmp>();
622
623
4
    return cmp->Run(ds, res, bnAbs, modulo);
624
4
}
625
626
3
bool SetBit::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
627
3
    (void)modulo;
628
3
    (void)ds;
629
630
3
    res = bn[0].Ref();
631
632
3
    const auto pos = detail::To_size_t(bn[1].Ref());
633
634
3
    if ( pos == std::nullopt ) {
635
0
        return false;
636
0
    }
637
638
3
    res.Ref().set_bit(*pos);
639
640
3
    return true;
641
3
}
642
643
6
bool ClearBit::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
644
6
    (void)modulo;
645
6
    (void)ds;
646
647
6
    res = bn[0].Ref();
648
649
6
    const auto pos = detail::To_size_t(bn[1].Ref());
650
651
6
    if ( pos == std::nullopt ) {
652
1
        return false;
653
1
    }
654
655
5
    res.Ref().clear_bit(*pos);
656
657
5
    return true;
658
6
}
659
660
8
bool MulAdd::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
661
8
    (void)modulo;
662
8
    (void)ds;
663
664
8
    res = (bn[0].Ref()*bn[1].Ref()) + bn[2].Ref();
665
666
8
    return true;
667
8
}
668
669
6
bool MulDiv::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
670
6
    (void)modulo;
671
6
    (void)ds;
672
673
6
    if ( bn[2].Ref() == 0 ) {
674
1
        return false;
675
1
    }
676
677
5
    res = (bn[0].Ref()*bn[1].Ref()+1) / bn[2].Ref();
678
679
5
    return true;
680
6
}
681
682
42
bool MulDivCeil::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
683
42
    (void)modulo;
684
42
    (void)ds;
685
686
42
    if ( bn[2].Ref() <= 0 ) {
687
1
        return false;
688
1
    }
689
690
41
    const auto mulRes = bn[0].Ref() * bn[1].Ref();
691
41
    const auto modRes = mulRes % bn[2].Ref();
692
41
    res = mulRes / bn[2].Ref() + (modRes != 0 ? 1 : 0);
693
694
41
    return true;
695
42
}
696
697
13
bool Exp2::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
698
13
    (void)modulo;
699
13
    (void)ds;
700
701
13
    if ( bn[0].Ref() < 1 ) {
702
1
        return false;
703
1
    }
704
705
12
    const size_t exponent = bn[0].Ref().word_at(0) - 1;
706
707
12
    res = Bignum(2).Ref() << exponent;
708
709
12
    return true;
710
13
}
711
712
7
bool NumLSZeroBits::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
713
7
    (void)modulo;
714
7
    (void)ds;
715
716
7
    res = ::Botan::low_zero_bits(bn[0].Ref());
717
718
7
    return true;
719
7
}
720
721
28
bool Sqrt::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
722
28
    (void)ds;
723
724
28
    try {
725
28
        const auto res2 = ::Botan::is_perfect_square(bn[0].Ref());
726
28
        if ( res2 == 0 ) {
727
25
            return false;
728
25
        }
729
730
3
        res = res2;
731
3
    } catch ( ::Botan::Invalid_Argument& e ) {
732
        /* is_perfect_square() is expected to throw in this case */
733
1
        if ( bn[0].Ref() < 1 ) {
734
1
            return false;
735
1
        }
736
737
        /* Rethrow */
738
0
        throw e;
739
1
    }
740
741
2
    APPLY_MODULO;
742
743
2
    return true;
744
28
}
745
746
29
bool AddMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
747
29
    (void)modulo;
748
29
    (void)ds;
749
750
29
    try {
751
29
        switch ( GET_UINT8_FOR_SWITCH() ) {
752
6
            case    0:
753
6
                res = (bn[0].Ref() + bn[1].Ref()) % bn[2].Ref();
754
6
                break;
755
7
            case    1:
756
7
                {
757
7
                    if ( bn[0].Ref() >= bn[2].Ref() ) {
758
2
                        return false;
759
2
                    }
760
5
                    if ( bn[1].Ref() >= bn[2].Ref() ) {
761
1
                        return false;
762
1
                    }
763
764
4
                    ::Botan::secure_vector<::Botan::word> ws;
765
4
                    try {
766
4
                        res = bn[0].Ref().mod_add(bn[1].Ref(), bn[2].Ref(), ws);
767
4
                    } catch ( ::Botan::Invalid_Argument& e ) {
768
                        /* mod_add is expected to throw an exception when any argument is negative */
769
0
                        if ( bn[0].Ref() < 0 || bn[1].Ref() < 0 || bn[2].Ref() < 0) {
770
0
                            return false;
771
0
                        }
772
773
                        /* Rethrow */
774
0
                        throw e;
775
0
                    }
776
4
                }
777
4
                break;
778
5
            default:
779
5
                return false;
780
29
        }
781
29
    } catch ( fuzzing::datasource::Datasource::OutOfData ) {
782
11
        return false;
783
11
    } catch ( ::Botan::Invalid_Argument& e ) {
784
        /* Botan is expected to throw an exception when modulo is <= 0 */
785
1
        if ( bn[2].Ref() <= 0 ) {
786
1
            return false;
787
1
        }
788
789
        /* Rethrow */
790
0
        throw e;
791
1
    }
792
793
9
    return true;
794
29
}
795
796
23
bool SubMod::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
797
23
    (void)modulo;
798
23
    (void)ds;
799
800
23
    try {
801
23
        switch ( GET_UINT8_FOR_SWITCH() ) {
802
6
            case    0:
803
6
                res = (bn[0].Ref() - bn[1].Ref()) % bn[2].Ref();
804
6
                break;
805
5
            case    1:
806
5
                {
807
5
                    if ( bn[0].Ref() >= bn[2].Ref() ) {
808
1
                        return false;
809
1
                    }
810
4
                    if ( bn[1].Ref() >= bn[2].Ref() ) {
811
1
                        return false;
812
1
                    }
813
814
3
                    ::Botan::secure_vector<::Botan::word> ws;
815
3
                    try {
816
3
                        res = bn[0].Ref().mod_sub(bn[1].Ref(), bn[2].Ref(), ws);
817
3
                    } catch ( ::Botan::Invalid_Argument& e ) {
818
                        /* mod_sub is expected to throw an exception when any argument is negative */
819
0
                        if ( bn[0].Ref() < 0 || bn[1].Ref() < 0 || bn[2].Ref() < 0) {
820
0
                            return false;
821
0
                        }
822
823
                        /* Rethrow */
824
0
                        throw e;
825
0
                    }
826
3
                }
827
3
                break;
828
6
            default:
829
6
                return false;
830
23
        }
831
23
    } catch ( fuzzing::datasource::Datasource::OutOfData ) {
832
6
        return false;
833
6
    } catch ( ::Botan::Invalid_Argument& e ) {
834
        /* Botan is expected to throw an exception when modulo is <= 0 */
835
3
        if ( bn[2].Ref() <= 0 ) {
836
3
            return false;
837
3
        }
838
839
        /* Rethrow */
840
0
        throw e;
841
3
    }
842
843
6
    return true;
844
23
}
845
846
7
bool NumBits::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
847
7
    (void)ds;
848
849
7
    if ( modulo ) {
850
6
        res = (bn[0].Ref() % modulo->ConstRef()).bits();
851
6
    } else {
852
1
        res = bn[0].Ref().bits();
853
1
    }
854
855
7
    return true;
856
7
}
857
858
13
bool Set::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
859
13
    (void)modulo;
860
13
    (void)ds;
861
862
13
    res = bn[0].Ref();
863
864
13
    APPLY_MODULO;
865
866
13
    return true;
867
13
}
868
869
37
bool CondSet::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
870
37
    (void)modulo;
871
37
    (void)ds;
872
873
37
    res.Ref().ct_cond_assign(bn[1].Ref() != 0, bn[0].Ref());
874
875
37
    return true;
876
37
}
877
878
86
bool Ressol::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
879
86
    (void)ds;
880
881
86
    try {
882
86
        auto mod = modulo == std::nullopt ? bn[1] : *modulo;
883
884
86
        const auto r = ::Botan::sqrt_modulo_prime(bn[0].Ref(), mod.Ref());
885
886
86
        if ( r < 1 ) {
887
30
            if ( modulo != std::nullopt ) {
888
30
                res = 0;
889
30
                return true;
890
30
            } else {
891
0
                return false;
892
0
            }
893
30
        }
894
895
56
        if ( modulo != std::nullopt ) {
896
54
            res = ::Botan::square(r) % mod.Ref();
897
54
        }
898
899
56
        return true;
900
86
    } catch ( ::Botan::Invalid_Argument& e ) {
901
        /* Expected to throw if called with non-prime argument */
902
903
2
        return false;
904
2
    }
905
86
}
906
907
28
bool Not::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
908
28
    (void)ds;
909
910
28
    Bignum max;
911
912
28
    if ( modulo ) {
913
18
        max = *modulo;
914
18
    } else {
915
10
        const size_t numBits = bn[0].Ref().bits();
916
917
10
        if ( numBits == 0 ) {
918
1
            return false;
919
1
        }
920
921
9
        max = (::Botan::BigInt(1) << numBits) - 1;
922
9
    }
923
924
27
    res = max.Ref() - bn[0].Ref();
925
926
27
    APPLY_MODULO;
927
928
27
    return true;
929
28
}
930
931
125
bool Prime::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
932
125
    (void)ds;
933
125
    (void)bn;
934
125
    (void)modulo;
935
936
125
    ::Botan::System_RNG rng;
937
125
    res = Botan::random_prime(rng, (rand() % 512) + 2);
938
939
125
    return true;
940
125
}
941
942
2
bool RandRange::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
943
2
    (void)ds;
944
2
    (void)modulo;
945
946
2
    try {
947
2
        ::Botan::System_RNG rng;
948
2
        res = ::Botan::BigInt::random_integer(rng, bn[0].Ref(), bn[1].Ref());
949
2
    } catch ( ::Botan::Invalid_Argument ) {
950
1
        return false;
951
1
    }
952
953
1
    return true;
954
2
}
955
956
25
bool IsSquare::Run(Datasource& ds, Bignum& res, std::vector<Bignum>& bn, const std::optional<Bignum>& modulo) const {
957
25
    (void)ds;
958
959
25
    if ( modulo != std::nullopt ) {
960
0
        return false;
961
0
    }
962
963
25
    try {
964
25
        res = ::Botan::is_perfect_square(bn[0].Ref()) == 0 ? 0 : 1;
965
25
    } catch ( ::Botan::Invalid_Argument& e ) {
966
        /* is_perfect_square() is expected to throw in this case */
967
1
        if ( bn[0].Ref() < 1 ) {
968
1
            return false;
969
1
        }
970
971
        /* Rethrow */
972
0
        throw e;
973
1
    }
974
975
24
    return true;
976
25
}
977
978
} /* namespace Botan_bignum */
979
} /* namespace module */
980
} /* namespace cryptofuzz */