/src/cryptofuzz/modules/libgmp/bn_ops.h

Source (jump to first uncovered line)
#include <cryptofuzz/components.h>
#include <cryptofuzz/operations.h>
#if !defined(MINI_GMP_PATH)
#include <gmp.h>
#else
extern "C" {
#include MINI_GMP_PATH
}
#define HAVE_MINI_GMP
#endif

namespace cryptofuzz {
namespace module {
namespace libgmp_bignum {

class Bignum {
    private:
        mpz_t mp;
    public:

        Bignum(void) {
            /* noret */ mpz_init(mp);
        }

        ~Bignum() {
            /* noret */ mpz_clear(mp);
        }

        bool Set(const std::string s) {
            bool ret = false;

            CF_CHECK_EQ(mpz_set_str(mp, s.c_str(), 10), 0);

            ret = true;
end:
            return ret;
        }

        mpz_ptr GetPtr(void) {
            return mp;
        }

        std::optional<signed long> GetSignedLong(void) {
            std::optional<signed long> ret = std::nullopt;

            CF_CHECK_EQ(mpz_fits_slong_p(GetPtr()), 1);

            ret = mpz_get_si(GetPtr());
end:
            return ret;
        }

        std::optional<unsigned long int> GetUnsignedLong(void) {
            std::optional<unsigned long int> ret = std::nullopt;

            CF_CHECK_EQ(mpz_fits_ulong_p(GetPtr()), 1);

            ret = mpz_get_ui(GetPtr());
end:
            return ret;
        }

        std::optional<component::Bignum> ToComponentBignum(void) {
            std::optional<component::Bignum> ret = std::nullopt;

            char* str = mpz_get_str(nullptr, 10, mp);
            ret = { std::string(str) };
            free(str);

            return ret;
        }

        inline bool operator==(const Bignum& rhs) {
            return mpz_cmp(mp, rhs.mp) == 0;
        }

        void Randomize(fuzzing::datasource::Datasource& ds) {
            std::vector<uint8_t> data;
            try {
                data = ds.GetData(0, 1, 1024);
            } catch ( fuzzing::datasource::Datasource::OutOfData ) { }

            if ( !data.empty() ) {
                /* ignore return value */ Set(util::BinToDec(data));
            }
        }
};

class BignumCluster {
    private:
        Datasource& ds;
        std::array<Bignum, 4> bn;
    public:
        BignumCluster(Datasource& ds, Bignum bn0, Bignum bn1, Bignum bn2, Bignum bn3) :
            ds(ds),
            bn({bn0, bn1, bn2, bn3})
        { }

        Bignum& operator[](const size_t index) {
            if ( index >= bn.size() ) {
                abort();
            }

            try {
                /* Rewire? */
                if ( ds.Get<bool>() == true ) {
                    /* Pick a random bignum */
                    const size_t newIndex = ds.Get<uint8_t>() % 4;

                    /* Same value? */
                    if ( bn[newIndex] == bn[index] ) {
                        /* Then return reference to other bignum */
                        return bn[newIndex];
                    }

                    /* Fall through */
                }
            } catch ( fuzzing::datasource::Datasource::OutOfData ) { }

            return bn[index];
        }

        Bignum& Get(const size_t index) {
            if ( index >= bn.size() ) {
                abort();
            }

            return bn[index];
        }

        bool Set(const size_t index, const std::string s) {
            if ( index >= bn.size() ) {
                abort();
            }

            return bn[index].Set(s);
        }

        mpz_ptr GetDestPtr(const size_t index) {
            return bn[index].GetPtr();
        }
};

class Operation {
    public:
        virtual bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const = 0;
        virtual ~Operation() { }
};

class Add : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Sub : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mul : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Div : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class ExpMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class GCD : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class ExtGCD_X : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class ExtGCD_Y : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Jacobi : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Cmp : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class LCM : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Xor : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class And : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Abs : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Neg : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Sqrt : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SqrtCeil : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Sqr : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class CmpAbs : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsZero : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsNeg : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class AddMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SubMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class MulMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SqrMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod_NIST_192 : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod_NIST_224: public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod_NIST_256 : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod_NIST_384 : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod_NIST_521 : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SetBit : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class ClearBit : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Bit : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class InvMod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsOdd : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsEven : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsPow2 : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class NumLSZeroBits : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Factorial : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Cbrt : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SqrtRem : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class CbrtRem : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Nthrt : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class NthrtRem : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsSquare : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Exp : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Or : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class AddMul : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class SubMul : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Primorial : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Lucas : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Fibonacci : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Set : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class BinCoeff : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class HamDist : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Mod : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsPower : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Prime : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class IsPrime : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

class Rand : public Operation {
    public:
        bool Run(Datasource& ds, Bignum& res, BignumCluster& bn) const override;
};

} /* namespace libgmp_bignum */
} /* namespace module */
} /* namespace cryptofuzz */

Coverage Report

Created: 2023-02-22 06:39

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 */