Coverage Report

Created: 2023-02-22 06:39

/src/cryptofuzz/modules/wolfcrypt/bn_helper.cpp
Line
Count
Source (jump to first uncovered line)
1
#include "bn_ops.h"
2
#include <iostream>
3
4
namespace cryptofuzz {
5
namespace module {
6
7
namespace wolfCrypt_detail {
8
#if defined(CRYPTOFUZZ_WOLFCRYPT_ALLOCATION_FAILURES)
9
    extern bool disableAllocationFailures;
10
    extern bool haveAllocFailure;
11
#endif
12
} /* namespace wolfCrypt_detail */
13
14
namespace wolfCrypt_bignum {
15
16
19.3k
Bignum::read_radix_error_t Bignum::read_radix(mp_int* dest, const std::string& str, const size_t base) {
17
19.3k
    return read_radix(dest, str.c_str(), base);
18
19.3k
}
19
20
19.4k
Bignum::read_radix_error_t Bignum::read_radix(mp_int* dest, const char* str, const size_t base) {
21
19.4k
    Bignum::read_radix_error_t ret;
22
23
    /* Create a temporary variable for storing the result of mp_read_radix,
24
     * because if mp_read_radix fails (e.g. due to allocation failure),
25
     * it will set the value of the destination variable to 0.
26
     *
27
     * See OSS-Fuzz 31709 / ZD 11834 for discussion. */
28
19.4k
    auto newMp = (mp_int*)util::malloc(sizeof(mp_int));
29
19.4k
    if ( mp_init(newMp) != MP_OKAY ) {
30
0
        util::free(newMp);
31
0
        return READ_RADIX_FAIL_MEMORY;
32
0
    }
33
34
19.4k
    wolfCrypt_detail::haveAllocFailure = false;
35
19.4k
    if ( mp_read_radix(newMp, str, base) != MP_OKAY ) {
36
692
        ret = wolfCrypt_detail::haveAllocFailure ? READ_RADIX_FAIL_MEMORY : READ_RADIX_FAIL_OTHER;
37
692
        goto end;
38
692
    }
39
40
18.7k
    wolfCrypt_detail::haveAllocFailure = false;
41
18.7k
    if ( mp_copy(newMp, dest) != MP_OKAY ) {
42
224
        ret = wolfCrypt_detail::haveAllocFailure ? READ_RADIX_FAIL_MEMORY : READ_RADIX_FAIL_OTHER;
43
224
        goto end;
44
224
    }
45
46
18.4k
    ret = READ_RADIX_OK;
47
48
19.4k
end:
49
19.4k
    CF_NORET(mp_clear(newMp));
50
19.4k
    util::free(newMp);
51
52
19.4k
    return ret;
53
18.4k
}
54
55
2.51k
void Bignum::baseConversion(void) const {
56
2.51k
#if !defined(WOLFSSL_SP_MATH)
57
2.51k
    uint8_t base = 2;
58
2.51k
    char* str = nullptr;
59
60
2.51k
    try { base = ds.Get<uint8_t>(); } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
61
62
#if defined(CRYPTOFUZZ_WOLFCRYPT_DEBUG)
63
    std::cout << "Convert to base " << std::to_string(base) << " and back" << std::endl;
64
#endif
65
2.51k
    {
66
2.51k
        int size;
67
2.51k
        CF_CHECK_EQ(mp_radix_size(mp, base, &size), MP_OKAY);
68
65
        CF_ASSERT(size > 0, "Output of mp_radix_size is 0 or less");
69
70
65
        str = (char*)util::malloc(size);
71
72
65
#if defined(WOLFSSL_SP_MATH) || defined(WOLFSSL_SP_MATH_ALL) || !defined(USE_FAST_MATH)
73
65
        CF_CHECK_EQ(mp_toradix(mp, str, base), MP_OKAY);
74
#else
75
        wolfCrypt_detail::haveAllocFailure = false;
76
        CF_ASSERT(
77
                    mp_toradix(mp, str, base) == MP_OKAY ||
78
                    wolfCrypt_detail::haveAllocFailure ||
79
                    base < 2 ||
80
                    base > 64,
81
                    "wolfCrypt cannot convert mp to string");
82
83
        /* If allocation failure occurred, then do not use 'str' */
84
        CF_CHECK_FALSE(wolfCrypt_detail::haveAllocFailure);
85
#endif
86
87
54
        {
88
54
            const auto ret = read_radix(mp, str, base);
89
54
            CF_ASSERT(ret == READ_RADIX_OK || ret == READ_RADIX_FAIL_MEMORY, "wolfCrypt cannot parse the output of mp_toradix");
90
54
        }
91
54
    }
92
93
2.51k
end:
94
2.51k
    util::free(str);
95
2.51k
#endif
96
2.51k
}
97
98
2.54k
void Bignum::binaryConversion(void) const {
99
2.54k
    uint8_t* data = nullptr;
100
2.54k
    CF_CHECK_EQ(mp_isneg(mp), 0);
101
102
2.54k
#if LIBWOLFSSL_VERSION_HEX == 0x05005001
103
2.54k
    {
104
        /* Old version of the binary conversion logic, which doesn't crash if
105
         * mp_to_unsigned_bin_len() succeeds with an undersized buffer.
106
         *
107
         * This logic is retained specifically to prevent the libecc
108
         * OSS-Fuzz fuzzer from crashing, because this uses an older version
109
         * of wolfCrypt (specifically 0x05005001), which still has the
110
         * mp_to_unsigned_bin_len() bug.
111
         */
112
113
2.54k
        const auto size = mp_unsigned_bin_size(mp);
114
2.54k
        CF_ASSERT(size >= 0, "mp_unsigned_bin_size returned negative value");
115
116
2.54k
        data = util::malloc(size);
117
2.54k
        CF_CHECK_EQ(mp_to_unsigned_bin_len(mp, data, size), MP_OKAY);
118
119
        /* Ensure no allocation failure occurs in mp_read_unsigned_bin
120
         * because this can leave the mp in a corrupted state
121
         */
122
1.98k
        const auto cached_disableAllocationFailures = wolfCrypt_detail::disableAllocationFailures;
123
1.98k
        wolfCrypt_detail::disableAllocationFailures = true;
124
125
1.98k
        CF_ASSERT(mp_read_unsigned_bin(mp, data, size) == MP_OKAY, "Cannot parse output of mp_to_unsigned_bin_len");
126
127
1.98k
        wolfCrypt_detail::disableAllocationFailures = cached_disableAllocationFailures;
128
1.98k
    }
129
#else
130
    {
131
        bool randomSize = false;
132
133
        try { randomSize = ds.Get<bool>(); } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
134
135
        size_t size = 0;
136
        int numBits = 0;
137
138
        if ( randomSize == false ) {
139
            const auto size2 = mp_unsigned_bin_size(mp);
140
            CF_ASSERT(size2 >= 0, "mp_unsigned_bin_size returned negative value");
141
            size = size2;
142
        } else {
143
            try {
144
                size = ds.Get<uint16_t>();
145
            } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
146
147
            numBits = mp_count_bits(mp);
148
            CF_ASSERT(numBits >= 0, "mp_count_bits result is negative");
149
        }
150
151
        data = util::malloc(size);
152
        CF_CHECK_EQ(mp_to_unsigned_bin_len(mp, data, size), MP_OKAY);
153
154
        CF_ASSERT(
155
                size * 8 >= static_cast<size_t>(numBits),
156
                "mp_to_unsigned_bin_len succeeded with undersized buffer");
157
158
        /* Ensure no allocation failure occurs in mp_read_unsigned_bin
159
         * because this can leave the mp in a corrupted state
160
         */
161
        const auto cached_disableAllocationFailures = wolfCrypt_detail::disableAllocationFailures;
162
        wolfCrypt_detail::disableAllocationFailures = true;
163
164
        if ( randomSize == false ) {
165
            CF_ASSERT(mp_read_unsigned_bin(mp, data, size) == MP_OKAY, "Cannot parse output of mp_to_unsigned_bin_len");
166
        } else {
167
            /* mp_read_unsigned_bin can fail if the input buffer is too large.
168
             *
169
             * Read into a temp variable, and copy to mp if reading succeeds, otherwise
170
             * retain old value in mp.
171
             */
172
            Bignum tmp(ds);
173
            if ( mp_read_unsigned_bin(tmp.GetPtrDirect(), data, size) == MP_OKAY ) {
174
                /* ignore result */ mp_copy(tmp.GetPtrDirect(), mp);
175
            }
176
        }
177
178
        wolfCrypt_detail::disableAllocationFailures = cached_disableAllocationFailures;
179
    }
180
#endif
181
182
183
2.54k
end:
184
2.54k
    util::free(data);
185
2.54k
}
186
187
88.3k
void Bignum::invariants(void) const {
188
88.3k
#if defined(WOLFSSL_SP_MATH) || defined(WOLFSSL_SP_MATH_ALL)
189
88.3k
    CF_ASSERT(mp->used <= mp->size, "used is larger than size");
190
#elif !defined(USE_FAST_MATH)
191
    CF_ASSERT(mp->used <= mp->alloc, "used is larger than size");
192
#endif
193
88.3k
}
194
195
Bignum::Bignum(Datasource& ds) :
196
28.2k
    ds(ds) {
197
28.2k
    mp = (mp_int*)util::malloc(sizeof(mp_int));
198
199
28.2k
    if ( init_mp_int(mp, ds) != MP_OKAY ) {
200
0
        util::free(mp);
201
0
        throw std::exception();
202
0
    }
203
28.2k
}
204
205
Bignum::Bignum(mp_int* mp, Datasource& ds) :
206
    mp(mp),
207
    ds(ds),
208
    noFree(true)
209
1.06k
{ }
210
211
Bignum::Bignum(const Bignum& other) :
212
17.7k
    ds(other.ds) {
213
17.7k
    mp = (mp_int*)util::malloc(sizeof(mp_int));
214
17.7k
    if ( init_mp_int(mp, ds) != MP_OKAY ) {
215
0
        util::free(mp);
216
0
        throw std::exception();
217
0
    }
218
17.7k
    if ( mp_copy(other.mp, mp) != MP_OKAY ) {
219
0
        util::free(mp);
220
0
        throw std::exception();
221
0
    }
222
17.7k
}
223
224
Bignum::Bignum(const Bignum&& other) :
225
17.7k
    ds(other.ds) {
226
17.7k
    mp = (mp_int*)util::malloc(sizeof(mp_int));
227
17.7k
    if ( init_mp_int(mp, ds) != MP_OKAY ) {
228
0
        util::free(mp);
229
0
        throw std::exception();
230
0
    }
231
17.7k
    if ( mp_copy(other.mp, mp) != MP_OKAY ) {
232
0
        util::free(mp);
233
0
        throw std::exception();
234
0
    }
235
17.7k
}
236
237
64.7k
Bignum::~Bignum() {
238
64.7k
    invariants();
239
64.7k
    if ( noFree == false ) {
240
63.6k
        CF_NORET(mp_clear(mp));
241
63.6k
        util::free(mp);
242
63.6k
    }
243
64.7k
}
244
245
0
void Bignum::SetNoFree(void) {
246
0
    noFree = true;
247
0
}
248
249
19.3k
bool Bignum::Set(const std::string s) {
250
19.3k
    bool ret = false;
251
252
19.3k
    bool hex = false;
253
19.3k
    try {
254
19.3k
        hex = ds.Get<bool>();
255
19.3k
    } catch ( ... ) { }
256
257
#if defined(WOLFSSL_SP_MATH)
258
    hex = true;
259
#endif
260
261
19.3k
    if ( hex == true ) {
262
2.58k
        CF_CHECK_EQ(read_radix(mp, util::DecToHex(s), 16), READ_RADIX_OK);
263
16.7k
    } else {
264
16.7k
        CF_CHECK_EQ(read_radix(mp, s, 10), READ_RADIX_OK);
265
15.9k
    }
266
267
18.4k
    ret = true;
268
19.3k
end:
269
19.3k
    return ret;
270
18.4k
}
271
272
1.66k
bool Bignum::Set(const component::Bignum i) {
273
1.66k
    bool ret = false;
274
275
1.66k
    CF_CHECK_EQ(Set(i.ToString()), true);
276
277
1.65k
    ret = true;
278
1.66k
end:
279
1.66k
    return ret;
280
1.65k
}
281
282
23.6k
mp_int* Bignum::GetPtr(void) const {
283
23.6k
    invariants();
284
285
23.6k
    {
286
        /* Optionally clamp the bignum. This should not affect its value. */
287
288
23.6k
        bool clamp = false;
289
290
23.6k
        try { clamp = ds.Get<bool>(); } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
291
292
23.6k
        if ( clamp ) {
293
            /* Implemented as a macro so CF_NORET cannot be used here */
294
2.60k
            /* noret */ mp_clamp(mp);
295
2.60k
        }
296
23.6k
    }
297
298
23.6k
    {
299
        /* Optionally convert to a random base and back */
300
301
23.6k
        bool convert = false;
302
303
23.6k
        try { convert = ds.Get<bool>(); } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
304
305
23.6k
        if ( convert ) {
306
2.51k
            baseConversion();
307
2.51k
        }
308
23.6k
    }
309
310
23.6k
    {
311
        /* Optionally convert to bytes and back */
312
313
23.6k
        bool convert = false;
314
315
23.6k
        try { convert = ds.Get<bool>(); } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
316
317
23.6k
        if ( convert ) {
318
2.54k
            binaryConversion();
319
2.54k
        }
320
23.6k
    }
321
322
23.6k
    return mp;
323
23.6k
}
324
325
23.9k
mp_int* Bignum::GetPtrDirect(void) const {
326
23.9k
    return mp;
327
23.9k
}
328
329
311
std::optional<uint64_t> Bignum::AsUint64(void) const {
330
311
    std::optional<uint64_t> ret = std::nullopt;
331
311
    uint64_t v = 0;
332
333
311
#if !defined(WOLFSSL_SP_MATH)
334
311
    CF_CHECK_EQ(mp_isneg(mp), 0);
335
311
#endif
336
311
    CF_CHECK_LTE(mp_count_bits(mp), (int)(sizeof(v) * 8));
337
284
    CF_CHECK_EQ(mp_to_unsigned_bin_len(mp, (uint8_t*)&v, sizeof(v)), MP_OKAY);
338
284
    v =
339
284
        ((v & 0xFF00000000000000) >> 56) |
340
284
        ((v & 0x00FF000000000000) >> 40) |
341
284
        ((v & 0x0000FF0000000000) >> 24) |
342
284
        ((v & 0x000000FF00000000) >>  8) |
343
284
        ((v & 0x00000000FF000000) <<  8) |
344
284
        ((v & 0x0000000000FF0000) << 24) |
345
284
        ((v & 0x000000000000FF00) << 40) |
346
284
        ((v & 0x00000000000000FF) << 56);
347
348
284
    ret = v;
349
311
end:
350
311
    return ret;
351
284
}
352
353
4.89k
std::optional<std::string> Bignum::ToDecString(void) {
354
4.89k
    std::optional<std::string> ret = std::nullopt;
355
4.89k
    char* str = nullptr;
356
357
#if defined(WOLFSSL_SP_MATH)
358
    str = (char*)util::malloc(8192);
359
360
    CF_CHECK_EQ(mp_tohex(mp, str), MP_OKAY);
361
    ret = { util::HexToDec(str) };
362
#else
363
4.89k
    bool hex = false;
364
4.89k
    int size;
365
366
4.89k
    try {
367
4.89k
        hex = ds.Get<bool>();
368
4.89k
    } catch ( ... ) { }
369
370
371
4.89k
    if ( hex == true ) {
372
407
        CF_CHECK_EQ(mp_radix_size(mp, 16, &size), MP_OKAY);
373
407
        CF_ASSERT(size > 0, "Output of mp_radix_size is 0 or less");
374
375
407
        str = (char*)util::malloc(size+1);
376
377
407
        CF_CHECK_EQ(mp_tohex(mp, str), MP_OKAY);
378
407
        ret = { util::HexToDec(str) };
379
4.48k
    } else {
380
4.48k
        CF_CHECK_EQ(mp_radix_size(mp, 10, &size), MP_OKAY);
381
4.34k
        CF_ASSERT(size > 0, "Output of mp_radix_size is 0 or less");
382
383
4.34k
        str = (char*)util::malloc(size);
384
385
4.34k
        CF_CHECK_EQ(mp_toradix(mp, str, 10), MP_OKAY);
386
4.27k
        ret = std::string(str);
387
4.27k
    }
388
4.68k
#endif
389
390
4.89k
end:
391
4.89k
    free(str);
392
393
4.89k
    return ret;
394
4.89k
}
395
396
2.59k
std::optional<component::Bignum> Bignum::ToComponentBignum(void) {
397
2.59k
    std::optional<component::Bignum> ret = std::nullopt;
398
399
2.59k
    auto str = ToDecString();
400
2.59k
    CF_CHECK_NE(str, std::nullopt);
401
2.50k
    ret = { str };
402
2.59k
end:
403
2.59k
    return ret;
404
2.50k
}
405
406
904
bool Bignum::ToBin(uint8_t* dest, const size_t size) {
407
904
    bool ret = false;
408
409
904
    const auto required = mp_unsigned_bin_size(GetPtr());
410
904
    CF_ASSERT(required >= 0, "mp_unsigned_bin_size returned negative value");
411
412
904
    CF_CHECK_GTE(size, static_cast<size_t>(required));
413
897
    CF_CHECK_EQ(mp_to_unsigned_bin_len(GetPtr(), dest, size), MP_OKAY);
414
415
880
    ret = true;
416
904
end:
417
904
    return ret;
418
880
}
419
420
421
723
std::optional<std::vector<uint8_t>> Bignum::ToBin(Datasource& ds, const component::Bignum b, std::optional<size_t> size) {
422
723
    std::optional<std::vector<uint8_t>> ret = std::nullopt;
423
723
    std::vector<uint8_t> v;
424
723
    Bignum bn(ds);
425
723
    uint16_t padding = 0;
426
427
723
    CF_CHECK_EQ(bn.Set(b), true);
428
721
    if ( size != std::nullopt ) {
429
0
        v.resize(*size);
430
721
    } else {
431
721
        try {
432
721
            padding = ds.Get<uint16_t>();
433
721
        } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
434
435
721
        v.resize( mp_unsigned_bin_size(bn.GetPtr()) + padding );
436
721
    }
437
438
721
    CF_CHECK_EQ(bn.ToBin(v.data(), v.size()), true);
439
440
704
    ret = v;
441
723
end:
442
723
    return ret;
443
704
}
444
445
bool Bignum::ToBin(
446
        Datasource& ds,
447
        const component::Bignum b,
448
        uint8_t* dest,
449
        const size_t size,
450
550
        const bool mustSucceed) {
451
550
    bool ret = false;
452
550
    if ( mustSucceed == true ) {
453
436
        std::optional<std::vector<uint8_t>> bytes;
454
436
        CF_CHECK_NE(bytes = util::DecToBin(b.ToTrimmedString(), size), std::nullopt);
455
428
        memcpy(dest, bytes->data(), bytes->size());
456
428
        ret = true;
457
428
    } else {
458
114
        Bignum bn(ds);
459
460
114
        CF_CHECK_EQ(bn.Set(b), true);
461
112
        CF_CHECK_EQ(bn.ToBin(dest, size), true);
462
463
110
        ret = true;
464
110
    }
465
550
end:
466
550
    return ret;
467
550
}
468
469
bool Bignum::ToBin(
470
        Datasource& ds,
471
        const component::BignumPair b,
472
        uint8_t* dest,
473
        const size_t size,
474
146
        const bool mustSucceed) {
475
146
    CF_ASSERT((size % 2) == 0, "Input size is not multiple of 2 in Bignum::ToBin");
476
477
146
    bool ret = false;
478
146
    const auto halfSize = size / 2;
479
480
146
    CF_CHECK_EQ(ToBin(ds, b.first, dest, halfSize, mustSucceed), true);
481
142
    CF_CHECK_EQ(ToBin(ds, b.second, dest + halfSize, halfSize, mustSucceed), true);
482
483
140
    ret = true;
484
146
end:
485
146
    return ret;
486
140
}
487
488
83
std::optional<component::Bignum> Bignum::BinToBignum(Datasource& ds, const uint8_t* src, const size_t size) {
489
83
    std::optional<component::Bignum> ret = std::nullopt;
490
491
83
    wolfCrypt_bignum::Bignum bn(ds);
492
83
    CF_CHECK_EQ(mp_read_unsigned_bin(bn.GetPtr(), src, size), MP_OKAY);
493
494
83
    ret = bn.ToComponentBignum();
495
496
83
end:
497
83
    return ret;
498
83
}
499
500
73
std::optional<component::BignumPair> Bignum::BinToBignumPair(Datasource& ds, const uint8_t* src, const size_t size) {
501
73
    CF_ASSERT((size % 2) == 0, "Input size is not multiple of 2 in Bignum::BinToBignumPair");
502
503
73
    std::optional<component::BignumPair> ret = std::nullopt;
504
73
    std::optional<component::Bignum> A, B;
505
73
    const auto halfSize = size / 2;
506
507
73
    {
508
73
        wolfCrypt_bignum::Bignum bn(ds);
509
73
        CF_CHECK_EQ(mp_read_unsigned_bin(bn.GetPtr(), src, halfSize), MP_OKAY);
510
72
        CF_CHECK_NE(A = bn.ToComponentBignum(), std::nullopt);
511
71
    }
512
513
0
    {
514
71
        wolfCrypt_bignum::Bignum bn(ds);
515
71
        CF_CHECK_EQ(mp_read_unsigned_bin(bn.GetPtr(), src + halfSize, halfSize), MP_OKAY);
516
69
        CF_CHECK_NE(B = bn.ToComponentBignum(), std::nullopt);
517
68
    }
518
519
520
0
    ret = {A->ToTrimmedString(), B->ToTrimmedString()};
521
522
73
end:
523
73
    return ret;
524
68
}
525
526
4.42k
void Bignum::Randomize(void) {
527
4.42k
    std::vector<uint8_t> data;
528
4.42k
    try {
529
4.42k
        data = ds.GetData(0, 1, 1024);
530
4.42k
    } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
531
532
4.42k
    if ( !data.empty() ) {
533
        /* ignore return value */ mp_read_unsigned_bin(GetPtrDirect(), data.data(), data.size());
534
404
    }
535
4.42k
}
536
537
898
bool Bignum::operator==(const Bignum& rhs) const {
538
898
    return mp_cmp(GetPtr(), rhs.GetPtr()) == MP_EQ;
539
898
}
540
541
BignumCluster::BignumCluster(Datasource& ds, Bignum bn0, Bignum bn1, Bignum bn2, Bignum bn3) :
542
    ds(ds),
543
    bn({bn0, bn1, bn2, bn3})
544
4.42k
{ }
545
546
4.42k
BignumCluster::~BignumCluster() {
547
22.1k
    for (size_t i = 0; i < 4; i++) {
548
17.7k
        if ( cache.bn[i] == nullptr ) {
549
3.55k
            continue;
550
3.55k
        }
551
552
14.1k
        mp_clear(cache.bn[i]);
553
14.1k
        util::free(cache.bn[i]);
554
14.1k
    }
555
4.42k
}
556
557
9.04k
Bignum& BignumCluster::operator[](const size_t index) {
558
9.04k
    CF_ASSERT(index < bn.size(), "Invalid index requested in BignumCluster::operator[]");
559
560
9.04k
    try {
561
        /* Rewire? */
562
9.04k
        if ( ds.Get<bool>() == true ) {
563
            /* Pick a random bignum */
564
920
            const auto newIndex = ds.Get<uint8_t>() % 4;
565
566
            /* Same value? */
567
920
            if ( bn[newIndex] == bn[index] ) {
568
                /* Then return reference to other bignum */
569
278
                return bn[newIndex];
570
278
            }
571
572
            /* Fall through */
573
920
        }
574
9.04k
    } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
575
576
8.77k
    return bn[index];
577
9.04k
}
578
579
15.2k
bool BignumCluster::Set(const size_t index, const std::string s) {
580
15.2k
    CF_ASSERT(index < bn.size(), "Invalid index requested in BignumCluster::Set");
581
582
15.2k
    return bn[index].Set(s);
583
15.2k
}
584
585
28
mp_int* BignumCluster::GetDestPtr(const size_t index) {
586
    /* Because it is requested as a destination pointer,
587
     * this bignum will be altered, hence invalidate
588
     * the cache
589
     */
590
28
    InvalidateCache();
591
592
28
    return bn[index].GetPtr();
593
28
}
594
595
3.53k
void BignumCluster::Save(void) {
596
17.6k
    for (size_t i = 0; i < 4; i++) {
597
14.1k
        mp_int* cached_mp = (mp_int*)util::malloc(sizeof(mp_int));
598
599
14.1k
        wolfCrypt_detail::disableAllocationFailures = true;
600
601
14.1k
        CF_ASSERT(mp_init(cached_mp) == MP_OKAY, "mp_init failed unexpectedly");
602
14.1k
        CF_ASSERT(mp_copy(bn[i].GetPtrDirect(), cached_mp) == MP_OKAY, "mp_copy failed unexpectedly");
603
604
14.1k
        wolfCrypt_detail::disableAllocationFailures = false;
605
606
14.1k
        cache.bn[i] = cached_mp;
607
14.1k
    }
608
3.53k
}
609
610
28
void BignumCluster::InvalidateCache(void) {
611
28
    cache.invalid = true;
612
28
}
613
614
2.37k
bool BignumCluster::EqualsCache(void) const {
615
2.37k
    if ( cache.invalid == true ) {
616
23
        return true;
617
23
    }
618
619
11.7k
    for (size_t i = 0; i < 4; i++) {
620
9.40k
        if ( cache.bn[i] == nullptr ) {
621
0
            continue;
622
0
        }
623
624
9.40k
        wolfCrypt_detail::disableAllocationFailures = true;
625
626
9.40k
        if ( mp_cmp(bn[i].GetPtrDirect(), cache.bn[i]) != MP_EQ ) {
627
#if defined(CRYPTOFUZZ_WOLFCRYPT_DEBUG)
628
            char str[8192];
629
630
            std::cout << "Bignum with index " << std::to_string(i) << " was changed" << std::endl;
631
632
            wolfCrypt_detail::disableAllocationFailures = true;
633
634
            CF_ASSERT(mp_tohex(cache.bn[i], str) == MP_OKAY, "mp_tohex failed unexpectedly");
635
            printf("it was: %s\n", str);
636
637
            CF_ASSERT(mp_tohex(bn[i].GetPtrDirect(), str) == MP_OKAY, "mp_tohex failed unexpectedly");
638
            printf("it is now %s\n", str);
639
640
#endif
641
0
            wolfCrypt_detail::disableAllocationFailures = false;
642
643
0
            return false;
644
0
        }
645
646
9.40k
        wolfCrypt_detail::disableAllocationFailures = false;
647
9.40k
    }
648
649
2.35k
    return true;
650
2.35k
}
651
652
} /* namespace wolfCrypt_bignum */
653
} /* namespace module */
654
} /* namespace cryptofuzz */