/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;
        std::optional<size_t> res_index = std::nullopt;
    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();
        }

        mpz_ptr GetResPtr(void) {
            CF_ASSERT(res_index == std::nullopt, "Reusing result pointer");

            res_index = 0;

            try { res_index = ds.Get<uint8_t>() % 4; }
            catch ( fuzzing::datasource::Datasource::OutOfData ) { }

            return bn[*res_index].GetPtr();
        }

        void CopyResult(Bignum& res) {
            CF_ASSERT(res_index != std::nullopt, "Result index is undefined");

            const auto src = bn[*res_index].GetPtr();
            auto dest = res.GetPtr();

            /* noret */ mpz_set(dest, src);
        }
};

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;
};

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

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

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

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

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

Coverage Report

Created: 2024-06-28 06:19

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