Coverage Report

Created: 2023-02-22 06:39

/src/cryptofuzz/modules/libgmp/bn_ops.h
Line
Count
Source (jump to first uncovered line)
1
#include <cryptofuzz/components.h>
2
#include <cryptofuzz/operations.h>
3
#if !defined(MINI_GMP_PATH)
4
#include <gmp.h>
5
#else
6
extern "C" {
7
#include MINI_GMP_PATH
8
}
9
#define HAVE_MINI_GMP
10
#endif
11
12
namespace cryptofuzz {
13
namespace module {
14
namespace libgmp_bignum {
15
16
class Bignum {
17
    private:
18
        mpz_t mp;
19
    public:
20
21
22.6k
        Bignum(void) {
22
            /* noret */ mpz_init(mp);
23
22.6k
        }
24
25
40.3k
        ~Bignum() {
26
            /* noret */ mpz_clear(mp);
27
40.3k
        }
28
29
18.9k
        bool Set(const std::string s) {
30
18.9k
            bool ret = false;
31
32
18.9k
            CF_CHECK_EQ(mpz_set_str(mp, s.c_str(), 10), 0);
33
34
18.9k
            ret = true;
35
18.9k
end:
36
18.9k
            return ret;
37
18.9k
        }
38
39
21.5k
        mpz_ptr GetPtr(void) {
40
21.5k
            return mp;
41
21.5k
        }
42
43
102
        std::optional<signed long> GetSignedLong(void) {
44
102
            std::optional<signed long> ret = std::nullopt;
45
46
102
            CF_CHECK_EQ(mpz_fits_slong_p(GetPtr()), 1);
47
48
70
            ret = mpz_get_si(GetPtr());
49
102
end:
50
102
            return ret;
51
70
        }
52
53
348
        std::optional<unsigned long int> GetUnsignedLong(void) {
54
348
            std::optional<unsigned long int> ret = std::nullopt;
55
56
348
            CF_CHECK_EQ(mpz_fits_ulong_p(GetPtr()), 1);
57
58
272
            ret = mpz_get_ui(GetPtr());
59
348
end:
60
348
            return ret;
61
272
        }
62
63
3.92k
        std::optional<component::Bignum> ToComponentBignum(void) {
64
3.92k
            std::optional<component::Bignum> ret = std::nullopt;
65
66
3.92k
            char* str = mpz_get_str(nullptr, 10, mp);
67
3.92k
            ret = { std::string(str) };
68
3.92k
            free(str);
69
70
3.92k
            return ret;
71
3.92k
        }
72
73
2.17k
        inline bool operator==(const Bignum& rhs) {
74
2.17k
            return mpz_cmp(mp, rhs.mp) == 0;
75
2.17k
        }
76
77
4.42k
        void Randomize(fuzzing::datasource::Datasource& ds) {
78
4.42k
            std::vector<uint8_t> data;
79
4.42k
            try {
80
4.42k
                data = ds.GetData(0, 1, 1024);
81
4.42k
            } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
82
83
4.42k
            if ( !data.empty() ) {
84
445
                /* ignore return value */ Set(util::BinToDec(data));
85
445
            }
86
4.42k
        }
87
};
88
89
class BignumCluster {
90
    private:
91
        Datasource& ds;
92
        std::array<Bignum, 4> bn;
93
    public:
94
        BignumCluster(Datasource& ds, Bignum bn0, Bignum bn1, Bignum bn2, Bignum bn3) :
95
            ds(ds),
96
            bn({bn0, bn1, bn2, bn3})
97
4.42k
        { }
98
99
14.9k
        Bignum& operator[](const size_t index) {
100
14.9k
            if ( index >= bn.size() ) {
101
0
                abort();
102
0
            }
103
104
14.9k
            try {
105
                /* Rewire? */
106
14.9k
                if ( ds.Get<bool>() == true ) {
107
                    /* Pick a random bignum */
108
2.22k
                    const size_t newIndex = ds.Get<uint8_t>() % 4;
109
110
                    /* Same value? */
111
2.22k
                    if ( bn[newIndex] == bn[index] ) {
112
                        /* Then return reference to other bignum */
113
559
                        return bn[newIndex];
114
559
                    }
115
116
                    /* Fall through */
117
2.22k
                }
118
14.9k
            } catch ( fuzzing::datasource::Datasource::OutOfData ) { }
119
120
14.4k
            return bn[index];
121
14.9k
        }
122
123
0
        Bignum& Get(const size_t index) {
124
0
            if ( index >= bn.size() ) {
125
0
                abort();
126
0
            }
127
0
128
0
            return bn[index];
129
0
        }
130
131
17.7k
        bool Set(const size_t index, const std::string s) {
132
17.7k
            if ( index >= bn.size() ) {
133
0
                abort();
134
0
            }
135
136
17.7k
            return bn[index].Set(s);
137
17.7k
        }
138
139
0
        mpz_ptr GetDestPtr(const size_t index) {
140
0
            return bn[index].GetPtr();
141
0
        }
142
};
143
144
class Operation {
145
    public:
146
        virtual bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const = 0;
147
4.08k
        virtual ~Operation() { }
148
};
149
150
class Add : public Operation {
151
    public:
152
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
153
};
154
155
class Sub : public Operation {
156
    public:
157
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
158
};
159
160
class Mul : public Operation {
161
    public:
162
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
163
};
164
165
class Div : public Operation {
166
    public:
167
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
168
};
169
170
class ExpMod : public Operation {
171
    public:
172
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
173
};
174
175
class GCD : public Operation {
176
    public:
177
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
178
};
179
180
class ExtGCD_X : public Operation {
181
    public:
182
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
183
};
184
185
class ExtGCD_Y : public Operation {
186
    public:
187
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
188
};
189
190
class Jacobi : public Operation {
191
    public:
192
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
193
};
194
195
class Cmp : public Operation {
196
    public:
197
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
198
};
199
200
class LCM : public Operation {
201
    public:
202
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
203
};
204
205
class Xor : public Operation {
206
    public:
207
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
208
};
209
210
class And : public Operation {
211
    public:
212
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
213
};
214
215
class Abs : public Operation {
216
    public:
217
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
218
};
219
220
class Neg : public Operation {
221
    public:
222
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
223
};
224
225
class Sqrt : public Operation {
226
    public:
227
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
228
};
229
230
class SqrtCeil : public Operation {
231
    public:
232
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
233
};
234
235
class Sqr : public Operation {
236
    public:
237
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
238
};
239
240
class CmpAbs : public Operation {
241
    public:
242
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
243
};
244
245
class IsZero : public Operation {
246
    public:
247
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
248
};
249
250
class IsNeg : public Operation {
251
    public:
252
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
253
};
254
255
class AddMod : public Operation {
256
    public:
257
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
258
};
259
260
class SubMod : public Operation {
261
    public:
262
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
263
};
264
265
class MulMod : public Operation {
266
    public:
267
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
268
};
269
270
class SqrMod : public Operation {
271
    public:
272
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
273
};
274
275
class Mod_NIST_192 : public Operation {
276
    public:
277
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
278
};
279
280
class Mod_NIST_224: public Operation {
281
    public:
282
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
283
};
284
285
class Mod_NIST_256 : public Operation {
286
    public:
287
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
288
};
289
290
class Mod_NIST_384 : public Operation {
291
    public:
292
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
293
};
294
295
class Mod_NIST_521 : public Operation {
296
    public:
297
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
298
};
299
300
class SetBit : public Operation {
301
    public:
302
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
303
};
304
305
class ClearBit : public Operation {
306
    public:
307
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
308
};
309
310
class Bit : public Operation {
311
    public:
312
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
313
};
314
315
class InvMod : public Operation {
316
    public:
317
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
318
};
319
320
class IsOdd : public Operation {
321
    public:
322
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
323
};
324
325
class IsEven : public Operation {
326
    public:
327
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
328
};
329
330
class IsPow2 : public Operation {
331
    public:
332
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
333
};
334
335
class NumLSZeroBits : public Operation {
336
    public:
337
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
338
};
339
340
class Factorial : public Operation {
341
    public:
342
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
343
};
344
345
class Cbrt : public Operation {
346
    public:
347
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
348
};
349
350
class SqrtRem : public Operation {
351
    public:
352
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
353
};
354
355
class CbrtRem : public Operation {
356
    public:
357
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
358
};
359
360
class Nthrt : public Operation {
361
    public:
362
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
363
};
364
365
class NthrtRem : public Operation {
366
    public:
367
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
368
};
369
370
class IsSquare : public Operation {
371
    public:
372
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
373
};
374
375
class Exp : public Operation {
376
    public:
377
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
378
};
379
380
class Or : public Operation {
381
    public:
382
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
383
};
384
385
class AddMul : public Operation {
386
    public:
387
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
388
};
389
390
class SubMul : public Operation {
391
    public:
392
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
393
};
394
395
class Primorial : public Operation {
396
    public:
397
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
398
};
399
400
class Lucas : public Operation {
401
    public:
402
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
403
};
404
405
class Fibonacci : public Operation {
406
    public:
407
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
408
};
409
410
class Set : public Operation {
411
    public:
412
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
413
};
414
415
class BinCoeff : public Operation {
416
    public:
417
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
418
};
419
420
class HamDist : public Operation {
421
    public:
422
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
423
};
424
425
class Mod : public Operation {
426
    public:
427
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
428
};
429
430
class IsPower : public Operation {
431
    public:
432
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
433
};
434
435
class Prime : public Operation {
436
    public:
437
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
438
};
439
440
class IsPrime : public Operation {
441
    public:
442
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
443
};
444
445
class Rand : public Operation {
446
    public:
447
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
448
};
449
450
} /* namespace libgmp_bignum */
451
} /* namespace module */
452
} /* namespace cryptofuzz */