From 9bdc6225b329c8d45b0078be9f053837226fcd0b Mon Sep 17 00:00:00 2001 From: dorian Date: Wed, 1 Apr 2020 13:00:37 +0200 Subject: [PATCH] initial add some libs --- Qt-Secret/.gitignore | 1 + Qt-Secret/LICENSE | 165 + Qt-Secret/Qt-Secret.pro | 16 + Qt-Secret/src/GMP/.gitignore | 1 + Qt-Secret/src/GMP/GMP.pri | 21 + Qt-Secret/src/GMP/GMP.pro | 38 + Qt-Secret/src/GMP/LICENSE | 21 + Qt-Secret/src/GMP/bigint.cpp | 618 +++ Qt-Secret/src/GMP/bigint.h | 206 + Qt-Secret/src/GMP/mini-gmp.c | 4415 +++++++++++++++++ Qt-Secret/src/GMP/mini-gmp.h | 303 ++ Qt-Secret/src/GMP/minigmp_global.h | 21 + Qt-Secret/src/Qt-RSA/qrsaencryption.cpp | 403 ++ Qt-Secret/src/Qt-RSA/qrsaencryption.h | 116 + Qt-Secret/src/Qt-Secret.pri | 24 + Qt-Secret/src/Qt-Secret.pro | 36 + Qt-Secret/src/build/debug/libQt-Secret.so | 1 + Qt-Secret/src/build/debug/libQt-Secret.so.1 | 1 + Qt-Secret/src/build/debug/libQt-Secret.so.1.2 | 1 + .../src/build/debug/libQt-Secret.so.1.2.0 | Bin 0 -> 595704 bytes Qt-Secret/src/build/release/libQt-Secret.so | 1 + Qt-Secret/src/build/release/libQt-Secret.so.1 | 1 + .../src/build/release/libQt-Secret.so.1.2 | 1 + .../src/build/release/libQt-Secret.so.1.2.0 | Bin 0 -> 125439 bytes Qt-Secret/src/qtsecret_global.h | 12 + 25 files changed, 6423 insertions(+) create mode 100644 Qt-Secret/.gitignore create mode 100644 Qt-Secret/LICENSE create mode 100644 Qt-Secret/Qt-Secret.pro create mode 100644 Qt-Secret/src/GMP/.gitignore create mode 100644 Qt-Secret/src/GMP/GMP.pri create mode 100644 Qt-Secret/src/GMP/GMP.pro create mode 100644 Qt-Secret/src/GMP/LICENSE create mode 100644 Qt-Secret/src/GMP/bigint.cpp create mode 100644 Qt-Secret/src/GMP/bigint.h create mode 100644 Qt-Secret/src/GMP/mini-gmp.c create mode 100644 Qt-Secret/src/GMP/mini-gmp.h create mode 100644 Qt-Secret/src/GMP/minigmp_global.h create mode 100644 Qt-Secret/src/Qt-RSA/qrsaencryption.cpp create mode 100644 Qt-Secret/src/Qt-RSA/qrsaencryption.h create mode 100644 Qt-Secret/src/Qt-Secret.pri create mode 100644 Qt-Secret/src/Qt-Secret.pro create mode 120000 Qt-Secret/src/build/debug/libQt-Secret.so create mode 120000 Qt-Secret/src/build/debug/libQt-Secret.so.1 create mode 120000 Qt-Secret/src/build/debug/libQt-Secret.so.1.2 create mode 100755 Qt-Secret/src/build/debug/libQt-Secret.so.1.2.0 create mode 120000 Qt-Secret/src/build/release/libQt-Secret.so create mode 120000 Qt-Secret/src/build/release/libQt-Secret.so.1 create mode 120000 Qt-Secret/src/build/release/libQt-Secret.so.1.2 create mode 100755 Qt-Secret/src/build/release/libQt-Secret.so.1.2.0 create mode 100644 Qt-Secret/src/qtsecret_global.h diff --git a/Qt-Secret/.gitignore b/Qt-Secret/.gitignore new file mode 100644 index 0000000..84c048a --- /dev/null +++ b/Qt-Secret/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/Qt-Secret/LICENSE b/Qt-Secret/LICENSE new file mode 100644 index 0000000..65c5ca8 --- /dev/null +++ b/Qt-Secret/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/Qt-Secret/Qt-Secret.pro b/Qt-Secret/Qt-Secret.pro new file mode 100644 index 0000000..e9fe755 --- /dev/null +++ b/Qt-Secret/Qt-Secret.pro @@ -0,0 +1,16 @@ +# +# Copyright (C) 2018-2019 QuasarApp. +# Distributed under the lgplv3 software license, see the accompanying +# Everyone is permitted to copy and distribute verbatim copies +# of this license document, but changing it is not allowed. +# + +TEMPLATE = subdirs +CONFIG += ordered + +SUBDIRS += \ + GMP \ + src + +GMP.file = src/GMP/GMP.pro +src.file = src/Qt-Secret.pro diff --git a/Qt-Secret/src/GMP/.gitignore b/Qt-Secret/src/GMP/.gitignore new file mode 100644 index 0000000..84c048a --- /dev/null +++ b/Qt-Secret/src/GMP/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/Qt-Secret/src/GMP/GMP.pri b/Qt-Secret/src/GMP/GMP.pri new file mode 100644 index 0000000..128faad --- /dev/null +++ b/Qt-Secret/src/GMP/GMP.pri @@ -0,0 +1,21 @@ +# +# Copyright (C) 2018-2019 QuasarApp. +# Distributed under the lgplv3 software license, see the accompanying +# Everyone is permitted to copy and distribute verbatim copies +# of this license document, but changing it is not allowed. +# + +!isEmpty(Qt_GMP_LIB):error("GMP.pri already included") +Qt_GMP_LIB = 1 + +#DEPENDS +CONFIG(release, debug|release): { + MINIGMP_LIBRARY_OUTPUT_DIR="$$PWD/build/release" +} else { + MINIGMP_LIBRARY_OUTPUT_DIR="$$PWD/build/debug" +} +unix:LIBS += -L$$MINIGMP_LIBRARY_OUTPUT_DIR -lQtBigInt + +win32:LIBS += -L$$MINIGMP_LIBRARY_OUTPUT_DIR -lQtBigInt + +INCLUDEPATH += "$$PWD" diff --git a/Qt-Secret/src/GMP/GMP.pro b/Qt-Secret/src/GMP/GMP.pro new file mode 100644 index 0000000..12cb6d2 --- /dev/null +++ b/Qt-Secret/src/GMP/GMP.pro @@ -0,0 +1,38 @@ +# +# Copyright (C) 2018-2019 QuasarApp. +# Distributed under the lgplv3 software license, see the accompanying +# Everyone is permitted to copy and distribute verbatim copies +# of this license document, but changing it is not allowed. +# + + +QT -= core gui + +TARGET = MiniGMP +TEMPLATE = lib + +DEFINES += MINIGMP_LIBRARY +DEFINES += QT_DEPRECATED_WARNINGS + +TARGET = QtBigInt + +CONFIG += static +VERSION = 6.1.2 + +CONFIG(release, debug|release): { + DESTDIR="$$PWD/build/release" +} else { + DESTDIR="$$PWD/build/debug" +} + +DISTFILES += \ + README \ + +HEADERS += \ + bigint.h \ + mini-gmp.h \ + minigmp_global.h + +SOURCES += \ + bigint.cpp \ + mini-gmp.c diff --git a/Qt-Secret/src/GMP/LICENSE b/Qt-Secret/src/GMP/LICENSE new file mode 100644 index 0000000..450ca25 --- /dev/null +++ b/Qt-Secret/src/GMP/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 QuasarApp + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Qt-Secret/src/GMP/bigint.cpp b/Qt-Secret/src/GMP/bigint.cpp new file mode 100644 index 0000000..4287886 --- /dev/null +++ b/Qt-Secret/src/GMP/bigint.cpp @@ -0,0 +1,618 @@ +//# +//# Copyright (C) 2018-2019 QuasarApp. +//# Distributed under the lgplv3 software license, see the accompanying +//# Everyone is permitted to copy and distribute verbatim copies +//# of this license document, but changing it is not allowed. +//# + +#include "bigint.h" +#include +#include +#include + +// constructors +BigInt::BigInt() { + mpz_init(data); +} + +BigInt::BigInt(const BigInt &val, int bitCount) { + if (bitCount > 0) { + mpz_init2(data, static_cast(bitCount)); + } else { + mpz_init(data); + } + + mpz_set(data, val.data); + +} + +BigInt::BigInt(const std::string &str, int base): + BigInt() { + mpz_set_str(data, str.c_str(), base); +} + +BigInt::BigInt(intMpz val): + BigInt() { + mpz_set_si(data, val); +} + +BigInt::BigInt(char item, unsigned int size, int base = 2): + BigInt(std::string(size, item),base) { +} + +std::string BigInt::getString(int base) const { + char *str = mpz_get_str(nullptr, base, data); + return str; +} + +BigInt::~BigInt() { + mpz_clear(data); +} + +BigInt &BigInt::powm(const BigInt &pow, const BigInt &mod) { + mpz_powm(data, data, pow.data, mod.data); + return *this; +} + +BigInt BigInt::powm(BigInt val, const BigInt &pow, const BigInt &mod) { + return val.powm(pow, mod); +} + +BigInt &BigInt::pow(uIntMpz pow) { + mpz_pow_ui(data, data, pow); + return *this; +} + +int BigInt::sizeBits() const { + return sizeBytes() * 8; +} + +int BigInt::sizeBytes() const { + return static_cast(mpz_size(data) * sizeof ((*data->_mp_d))); +} + +int BigInt::longBits() const { + return static_cast(getString(2).size()); +} + +int BigInt::longBytes() const { + return static_cast(std::ceil(static_cast(longBits()) / 8)); +} + +#define GMP_ABS(x) ((x) >= 0 ? (x) : -(x)) +int BigInt::sizeType() const { + return static_cast(static_cast(GMP_ABS( data->_mp_alloc)) * + sizeof ((*data->_mp_d))); + +} + +bool BigInt::isPrime(bool absalut) const { + return (mpz_probab_prime_p(data, 50) - (absalut? 1: 0)) > 0; +} + +BigInt& BigInt::gcd(const BigInt &a, const BigInt &b) { + mpz_gcd(data, a.data, b.data); + return *this; + +} + +void BigInt::fromHex(const std::string &hex) { + mpz_set_str(data, hex.c_str(), 16); +} + +BigInt BigInt::bigPow10(unsigned short pow) { + return "1" + std::string(pow, '0'); +} + +BigInt &BigInt::toNegative() { + mpz_neg(data, data); + return *this; +} + +BigInt &BigInt::operator =(const BigInt &val) { + mpz_set(data, val.data); + return *this; +} + +BigInt &BigInt::operator =(const std::string &imput) { + mpz_set_str(data, imput.c_str(), 10); + return *this; +} + +BigInt &BigInt::operator =(intMpz val) { + mpz_set_si(data, val); + return *this; +} + +// add operators + +BigInt operator +(BigInt left, intMpz right) { + if (right >= 0) { + mpz_add_ui(left.data, left.data, static_cast(right)); + return left; + } + + return left -= std::abs(right); +} + +BigInt operator +(intMpz left, BigInt right) { + return right += left; +} + +BigInt operator +(BigInt left, const BigInt &right) { + mpz_add(left.data, left.data, right.data); + return left; +} + +BigInt operator +(BigInt left, const std::string &right) { + return left += BigInt(right); +} + +BigInt operator +(const std::string &left, const BigInt &right) { + return BigInt(left) + right; +} + +BigInt& operator +=(BigInt &left, intMpz right) { + if (right >= 0) { + mpz_add_ui(left.data, left.data, static_cast(right)); + return left; + } + return left -= std::abs(right); +} + +BigInt& operator +=(BigInt &left, const BigInt &right) { + mpz_add(left.data, left.data, right.data); + return left; +} + +BigInt& operator +=(BigInt &left, const std::string &right) { + return left += BigInt(right); +} + +// sub operators + +BigInt operator -(BigInt left, const BigInt &right) { + mpz_sub(left.data, left.data, right.data); + return left; +} + +BigInt operator -(BigInt left, intMpz right) { + if (right >= 0) { + mpz_sub_ui(left.data, left.data, static_cast(right)); + return left; + } + return left += std::abs(right); +} + +BigInt operator -(intMpz left, BigInt right) { + if (left >= 0) { + mpz_ui_sub(right.data, static_cast(left), right.data); + return right; + } + return right += std::abs(left); +} + +BigInt operator-(BigInt val) { + mpz_neg(val.data, val.data); + return val; +} + +BigInt operator -(BigInt left, const std::string &right) { + return left -= BigInt(right); +} + +BigInt operator -(const std::string & left, const BigInt &right) { + return BigInt(left) - right; +} + +BigInt& operator -=(BigInt &left, const BigInt &right) { + mpz_sub(left.data, left.data, right.data); + return left; +} + +BigInt& operator -=(BigInt &left, const std::string &right) { + return left -= BigInt(right); +} + +BigInt& operator -=(BigInt &left, intMpz right) { + if (right >= 0) { + mpz_sub_ui(left.data, left.data, static_cast(right)); + return left; + } + return left += std::abs(right); +} + +// div operators + +BigInt operator /(BigInt left, const BigInt &right) { + mpz_tdiv_q(left.data, left.data, right.data); + return left; +} + +BigInt operator /(BigInt left, intMpz right) { + mpz_tdiv_q_ui(left.data, left.data, static_cast(std::abs(right))); + + if (right >= 0) { + return left; + } + return -left; +} + +BigInt operator /(BigInt left, const std::string &right) { + return left /= BigInt(right); +} + +BigInt operator /(intMpz left, BigInt right) { + return BigInt(left) / right; +} + +BigInt operator /(const std::string & left, const BigInt &right) { + return BigInt(left) / right; +} + +BigInt& operator /=(BigInt &left, const BigInt &right) { + mpz_tdiv_q(left.data, left.data, right.data); + return left; +} + +BigInt& operator /=(BigInt &left, const std::string &right) { + return left /= BigInt(right); +} + +BigInt& operator /=(BigInt &left, intMpz right) { + mpz_tdiv_q_ui(left.data, left.data, static_cast(std::abs(right))); + + if (right >= 0) { + return left; + } + return left.toNegative(); +} + +// mul operators +BigInt operator *(BigInt left, const BigInt &right) { + mpz_mul(left.data, left.data, right.data); + return left; +} + +BigInt operator *(BigInt left, intMpz right) { + mpz_mul_ui(left.data, left.data, static_cast(std::abs(right))); + + if (right >= 0) { + return left; + } + return -left; +} + +BigInt operator *(intMpz left, BigInt right) { + return right *= left; +} + +BigInt operator *(const std::string & left, BigInt right) { + return right *= BigInt(left); +} + +BigInt operator *(BigInt left, const std::string &right) { + return left *= BigInt(right); +} + +BigInt& operator *=(BigInt &left, const BigInt &right) { + mpz_mul(left.data, left.data, right.data); + return left; +} + +BigInt& operator *=(BigInt &left, const std::string &right) { + return left *= BigInt(right); +} + +BigInt& operator *=(BigInt &left, intMpz right) { + mpz_mul_ui(left.data, left.data, static_cast(std::abs(right))); + + if (right >= 0) { + return left; + } + return left.toNegative(); +} + +//mod operations +BigInt operator %(BigInt left, const BigInt &right) { + mpz_tdiv_r(left.data, left.data, right.data); + return left; +} + +BigInt operator %(BigInt left, intMpz right) { + mpz_tdiv_r_ui(left.data, left.data, static_cast(std::abs(right))); + return left; +} + +BigInt operator %(intMpz left, BigInt right) { + return BigInt(left) % right; +} + +BigInt operator %(BigInt left, const std::string & right) { + return left %= BigInt(right); +} + +BigInt operator %(const std::string & left, const BigInt &right) { + return BigInt(left) % right; +} + +BigInt& operator %=(BigInt& left, const BigInt &right) { + mpz_tdiv_r(left.data, left.data, right.data); + return left; +} + +BigInt& operator %=(BigInt& left, intMpz right) { + mpz_tdiv_r_ui(left.data, left.data, static_cast(std::abs(right))); + return left; +} + +BigInt& operator %=(BigInt &left, const std::string &right) { + return left %= BigInt(right); +} + +// incriment and dicriment +BigInt &BigInt::operator--() { + *this -= 1; + return *this; +} + +BigInt &BigInt::operator++() { + *this += 1; + return *this; +} + +BigInt BigInt::operator--(int) { + BigInt temp(*this); + --*this; + return temp; +} + +BigInt BigInt::operator++(int) { + BigInt temp(*this); + ++*this; + return temp; +} + +// move operators + +BigInt operator >>(BigInt left, int right) { + if (right >= 0) { + mpn_rshift(left.data->_mp_d, + left.data->_mp_d, + left.data->_mp_size, + static_cast(std::abs(right))); + return left; + } + + return left << right; +} + +BigInt operator <<(BigInt left, int right) { + if (right >= 0) { + mpn_lshift(left.data->_mp_d, + left.data->_mp_d, + left.data->_mp_size, + static_cast(std::abs(right))); + return left; + } + + return left >> right; +} + +BigInt& operator >>=(BigInt &left, int right) { + if (right >= 0) { + mpn_rshift(left.data->_mp_d, + left.data->_mp_d, + left.data->_mp_size, + static_cast(std::abs(right))); + return left; + } + + return left <<= right; +} + +BigInt& operator <<=(BigInt &left, int right) { + if (right >= 0) { + mpn_lshift(left.data->_mp_d, + left.data->_mp_d, + left.data->_mp_size, + static_cast(std::abs(right))); + return left; + } + + return left >>= right; +} + +// other bin operators +BigInt operator ~(BigInt left) { + mpz_com(left.data, left.data); + return left; +} + +BigInt operator |(BigInt left, const BigInt &right) { + mpz_ior(left.data, left.data, right.data); + return left; +} + +BigInt operator |(const BigInt &left, intMpz right) { + return left | BigInt(right); +} + +BigInt& operator |=(BigInt &left, const BigInt &right) { + mpz_ior(left.data, left.data, right.data); + return left; +} + +BigInt& operator |=(BigInt &left, intMpz right) { + return left |= BigInt(right); +} + +BigInt operator &(BigInt left, const BigInt &right) { + mpz_and(left.data, left.data, right.data); + return left; +} + +BigInt operator &(const BigInt &left, intMpz right) { + return left & BigInt(right); +} + + +BigInt& operator &=(BigInt &left, const BigInt &right) { + mpz_and(left.data, left.data, right.data); + return left; +} + +BigInt& operator &=(BigInt &left, intMpz right) { + return left &= BigInt(right); +} + +BigInt operator ^(BigInt left, const BigInt &right) { + mpz_xor(left.data, left.data, right.data); + return left; +} + +BigInt operator ^(const BigInt &left, intMpz right) { + return left ^ BigInt(right); +} + +BigInt& operator ^=(BigInt &left, const BigInt &right) { + mpz_xor(left.data, left.data, right.data); + return left; +} + +BigInt& operator ^=(BigInt &left, intMpz right) { + return left ^= BigInt(right); +} + + +// logic operators + +bool operator!(const BigInt &val) { + return val == 0; +} + +bool operator == (const BigInt& left, const BigInt& right) { + return mpz_cmp(left.data, right.data) == 0; +} + +bool operator == (const BigInt& left, intMpz right) { + return mpz_cmp_si(left.data, right) == 0; +} + +bool operator == (const BigInt &left, const std::string &right) { + return left == BigInt(right); +} + +bool operator == ( intMpz left, const BigInt & right) { + return right == left; +} + +bool operator == ( const std::string & left, const BigInt & right) { + return right == BigInt(left); +} + +bool operator != (const BigInt &left, const BigInt& right) { + return !(left == right); +} + +bool operator != (const BigInt &left, intMpz right) { + return !(left == right); +} + +bool operator != (const BigInt &left, const std::string &right) { + return left != BigInt(right); +} + +bool operator != ( intMpz left, const BigInt & right) { + return right != left; +} + +bool operator != ( const std::string & left, const BigInt & right) { + return right != BigInt(left); +} + +bool operator < ( const BigInt &left, const BigInt& right) { + return mpz_cmp(left.data, right.data) < 0; +} + +bool operator < ( const BigInt &left, intMpz right) { + return mpz_cmp_si(left.data, right) < 0; +} + +bool operator < ( const BigInt &left, const std::string &right) { + return left < BigInt(right); +} + +bool operator < ( intMpz left, const BigInt & right) { + return right > left; +} + +bool operator < ( const std::string & left, const BigInt & right) { + return right > BigInt(left); +} + +bool operator > ( const BigInt &left, const BigInt& right) { + return mpz_cmp(left.data, right.data) > 0; +} + +bool operator > ( const BigInt &left, intMpz right) { + return mpz_cmp_si(left.data, right) > 0; +} + +bool operator > ( const BigInt &left, const std::string &right) { + return left > BigInt(right); +} + +bool operator > ( intMpz left, const BigInt & right) { + return right < left; +} + +bool operator > ( const std::string & left, const BigInt & right) { + return right < BigInt(left); +} + +bool operator <= ( const BigInt &left, const BigInt& right) { + return mpz_cmp(left.data, right.data) <= 0; +} + +bool operator <= ( const BigInt &left, intMpz right) { + return mpz_cmp_si(left.data, right) <= 0; +} + +bool operator <= ( const BigInt &left, const std::string &right) { + return left <= BigInt(right); +} + +bool operator <= ( intMpz left, const BigInt & right) { + return right >= left; +} + +bool operator <= ( const std::string & left, const BigInt & right) { + return right >= BigInt(left); +} + +bool operator >= ( const BigInt &left, const BigInt& right) { + return mpz_cmp(left.data, right.data) >= 0; +} + +bool operator >= ( const BigInt &left, intMpz right) { + return mpz_cmp_si(left.data, right) >= 0; +} + +bool operator >= ( const BigInt &left, const std::string &right) { + return left >= BigInt(right); +} + +bool operator >= ( intMpz left, const BigInt & right) { + return right <= left; +} + +bool operator >= ( const std::string & left, const BigInt & right) { + return right <= BigInt(left); +} + +//// cast operations + +//BigInt::operator bool() const { +// return *this != 0; +//} diff --git a/Qt-Secret/src/GMP/bigint.h b/Qt-Secret/src/GMP/bigint.h new file mode 100644 index 0000000..6a7d3a6 --- /dev/null +++ b/Qt-Secret/src/GMP/bigint.h @@ -0,0 +1,206 @@ +//# +//# Copyright (C) 2018-2019 QuasarApp. +//# Distributed under the lgplv3 software license, see the accompanying +//# Everyone is permitted to copy and distribute verbatim copies +//# of this license document, but changing it is not allowed. +//# + + +#ifndef BIGINT_H +#define BIGINT_H +#include "mini-gmp.h" +#include +#include +#include "minigmp_global.h" + +/** + * @brief The BigInt class - c++ minigmp wrapper + */ + +class MINIGMPSHARED_EXPORT BigInt +{ + mpz_t data; +public: + BigInt(); + BigInt(const BigInt& val, int bitCount = -1); + BigInt(const std::string &imput, int base = 10); + BigInt(intMpz val); + BigInt(char item, unsigned int size, int base); + + std::string getString(int base = 10) const; + ~BigInt(); + + BigInt& powm(const BigInt &pow, const BigInt &mod); + static BigInt powm(BigInt val, const BigInt & pow, const BigInt &mod); + + BigInt& pow(uIntMpz pow); + BigInt& log(int base); + /** + * @brief sizeBits + * @return size of bits in memory + */ + int sizeBits() const; + int sizeBytes() const; + + /** + * @brief longBits + * @return current length in Bits of number + */ + int longBits() const; + int longBytes() const; + + int sizeType() const; + bool isPrime(bool absalut = false) const; + BigInt& gcd(const BigInt &a, const BigInt &b); + void fromHex(const std::string& hex); + + /** + * @brief bigPow10 + * @param pow + * @return number 10 ^ pow + */ + static BigInt bigPow10(unsigned short pow); + + BigInt& toNegative(); + + BigInt& operator = (const BigInt& val); + BigInt& operator = (const std::string &imput); + BigInt& operator = (intMpz val); + + friend BigInt operator + ( BigInt left, const BigInt& right); + friend BigInt operator + ( BigInt left, const std::string &right); + friend BigInt operator + ( BigInt left, intMpz right); + + friend BigInt operator + ( intMpz left, BigInt right); + friend BigInt operator + ( const std::string &left, const BigInt &right); + + friend BigInt& operator += ( BigInt &left, intMpz right); + friend BigInt& operator += ( BigInt &left, const BigInt& right); + friend BigInt& operator += ( BigInt &left, const std::string &right); + + friend BigInt operator - ( BigInt left, const BigInt& right); + friend BigInt operator - ( BigInt left, intMpz right); + friend BigInt operator - ( BigInt left, const std::string &right); + + friend BigInt operator - ( intMpz right, BigInt left); + friend BigInt operator - ( const std::string &right, const BigInt &left); + + friend BigInt operator-(BigInt val); + + friend BigInt& operator -= ( BigInt &left, intMpz right); + + friend BigInt& operator -= ( BigInt &left, const BigInt& right); + friend BigInt& operator -= ( BigInt &left, const std::string &right); + + friend BigInt operator / ( BigInt left, const BigInt& right); + friend BigInt operator / ( BigInt left, const std::string &right); + friend BigInt operator / ( BigInt left, intMpz right); + friend BigInt operator / ( intMpz left, BigInt right); + friend BigInt operator / ( const std::string &left, const BigInt &right); + + friend BigInt& operator /= ( BigInt &left, intMpz right); + friend BigInt& operator /= ( BigInt &left, const std::string &right); + friend BigInt& operator /= ( BigInt &left, const BigInt& right); + + friend BigInt operator * ( BigInt left, const BigInt& right); + friend BigInt operator * ( BigInt left, const std::string &right); + friend BigInt operator * ( BigInt left, intMpz right); + + friend BigInt operator * ( intMpz left, BigInt right); + + friend BigInt& operator *= ( BigInt &left, const BigInt& right); + friend BigInt& operator *= ( BigInt &left, intMpz right); + friend BigInt& operator *= ( BigInt &left, const std::string &right); + + friend BigInt operator % ( BigInt left, const BigInt& right); + friend BigInt operator % ( BigInt left, const std::string &right); + friend BigInt operator % ( BigInt left, intMpz right); + + friend BigInt operator % ( intMpz left, BigInt right); + friend BigInt operator % ( const std::string & left, const BigInt &right); + + friend BigInt& operator %= ( BigInt &left, intMpz right); + friend BigInt& operator %= ( BigInt &left, const std::string &right); + + friend BigInt& operator %= ( BigInt &left, const BigInt& right); + + friend BigInt operator << ( BigInt left, int right); + friend BigInt operator >> ( BigInt left, int right); + + friend BigInt& operator <<= ( BigInt &left, int right); + friend BigInt& operator >>= ( BigInt &left, int right); + + friend bool operator == ( const BigInt& left, const BigInt& right); + friend bool operator == ( const BigInt& left, intMpz right); + friend bool operator == ( const BigInt& left, const std::string& right); + friend bool operator == ( const std::string& left, const BigInt& right); + friend bool operator == ( const BigInt& left, const std::string& right); + friend bool operator == ( intMpz left, const std::string& right); + + friend bool operator != ( const BigInt& left, const BigInt& right); + friend bool operator != ( const BigInt& left, intMpz right); + friend bool operator != ( const BigInt& left, const std::string& str); + friend bool operator != ( const std::string& left, const BigInt& right); + friend bool operator != ( const BigInt& left, const std::string& right); + friend bool operator != ( intMpz left, const std::string& right); + + friend bool operator < ( const BigInt& left, const BigInt& right); + friend bool operator < ( const BigInt& left, intMpz right); + friend bool operator < ( const BigInt& left, const std::string& str); + friend bool operator < ( const std::string& left, const BigInt& right); + friend bool operator < ( const BigInt& left, const std::string& right); + friend bool operator < ( intMpz left, const std::string& right); + + friend bool operator > ( const BigInt& left, const BigInt& right); + friend bool operator > ( const BigInt& left, intMpz right); + friend bool operator > ( const BigInt& left, const std::string& str); + friend bool operator > ( const std::string& left, const BigInt& right); + friend bool operator > ( const BigInt& left, const std::string& right); + friend bool operator > ( intMpz left, const std::string& right); + + friend bool operator <= ( const BigInt& left, const BigInt& right); + friend bool operator <= ( const BigInt& left, intMpz right); + friend bool operator <= ( const BigInt& left, const std::string& str); + friend bool operator <= ( const std::string& left, const BigInt& right); + friend bool operator <= ( const BigInt& left, const std::string& right); + friend bool operator <= ( intMpz left, const std::string& right); + + friend bool operator >= ( const BigInt& left, const BigInt& right); + friend bool operator >= ( const BigInt& left, intMpz right); + friend bool operator >= ( const BigInt& left, const std::string& str); + friend bool operator >= ( const std::string& left, const BigInt& right); + friend bool operator >= ( const BigInt& left, const std::string& right); + friend bool operator >= ( intMpz left, const std::string& right); + + friend bool operator!(const BigInt& val); + + BigInt& operator-- (); + BigInt& operator++ (); + + BigInt operator-- (int); + BigInt operator++ (int); + + + friend BigInt operator~ (BigInt val); + + friend BigInt operator| (BigInt left, const BigInt& right); + friend BigInt operator| (const BigInt &left, intMpz right); + + friend BigInt& operator|= (BigInt &left, const BigInt& right); + friend BigInt& operator|= (BigInt &left, intMpz right); + + friend BigInt operator& (BigInt left, const BigInt& right); + friend BigInt operator& (const BigInt &left, intMpz right); + + friend BigInt& operator&= (BigInt &left, const BigInt& right); + friend BigInt& operator&= (BigInt &left, intMpz right); + + friend BigInt operator^ (BigInt left, const BigInt& right); + friend BigInt operator^ (const BigInt &left, intMpz right); + + friend BigInt& operator^= (BigInt &left, const BigInt& right); + friend BigInt& operator^= (BigInt &left, intMpz right); + +}; + +#endif // BIGINT_H diff --git a/Qt-Secret/src/GMP/mini-gmp.c b/Qt-Secret/src/GMP/mini-gmp.c new file mode 100644 index 0000000..f9d598b --- /dev/null +++ b/Qt-Secret/src/GMP/mini-gmp.c @@ -0,0 +1,4415 @@ +/* mini-gmp, a minimalistic implementation of a GNU GMP subset. + + Contributed to the GNU project by Niels Möller + +Copyright 1991-1997, 1999-2016 Free Software Foundation, Inc. + +This file is part of the GNU MP Library. + +The GNU MP Library is free software; you can redistribute it and/or modify +it under the terms of either: + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your + option) any later version. + +or + + * the GNU General Public License as published by the Free Software + Foundation; either version 2 of the License, or (at your option) any + later version. + +or both in parallel, as here. + +The GNU MP Library is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received copies of the GNU General Public License and the +GNU Lesser General Public License along with the GNU MP Library. If not, +see https://www.gnu.org/licenses/. */ + +/* NOTE: All functions in this file which are not declared in + mini-gmp.h are internal, and are not intended to be compatible + neither with GMP nor with future versions of mini-gmp. */ + +/* Much of the material copied from GMP files, including: gmp-impl.h, + longlong.h, mpn/generic/add_n.c, mpn/generic/addmul_1.c, + mpn/generic/lshift.c, mpn/generic/mul_1.c, + mpn/generic/mul_basecase.c, mpn/generic/rshift.c, + mpn/generic/sbpi1_div_qr.c, mpn/generic/sub_n.c, + mpn/generic/submul_1.c. */ + +#include +#include +#include +#include +#include +#include + +#include "mini-gmp.h" + + +/* Macros */ +#define GMP_LIMB_BITS (sizeof(mp_limb_t) * CHAR_BIT) + +#define GMP_LIMB_MAX (~ (mp_limb_t) 0) +#define GMP_LIMB_HIGHBIT ((mp_limb_t) 1 << (GMP_LIMB_BITS - 1)) + +#define GMP_HLIMB_BIT ((mp_limb_t) 1 << (GMP_LIMB_BITS / 2)) +#define GMP_LLIMB_MASK (GMP_HLIMB_BIT - 1) + +#define GMP_ULONG_BITS (sizeof(uIntMpz) * CHAR_BIT) +#define GMP_ULONG_HIGHBIT ((uIntMpz) 1 << (GMP_ULONG_BITS - 1)) + +#define GMP_ABS(x) ((x) >= 0 ? (x) : -(x)) +#define GMP_NEG_CAST(T,x) (-((T)((x) + 1) - 1)) + +#define GMP_MIN(a, b) ((a) < (b) ? (a) : (b)) +#define GMP_MAX(a, b) ((a) > (b) ? (a) : (b)) + +#define GMP_CMP(a,b) (((a) > (b)) - ((a) < (b))) + +#define gmp_assert_nocarry(x) do { \ + mp_limb_t __cy = (x); \ + assert (__cy == 0); \ + } while (0) + +#define gmp_clz(count, x) do { \ + mp_limb_t __clz_x = (x); \ + unsigned __clz_c; \ + for (__clz_c = 0; \ + (__clz_x & ((mp_limb_t) 0xff << (GMP_LIMB_BITS - 8))) == 0; \ + __clz_c += 8) \ + __clz_x <<= 8; \ + for (; (__clz_x & GMP_LIMB_HIGHBIT) == 0; __clz_c++) \ + __clz_x <<= 1; \ + (count) = __clz_c; \ + } while (0) + +#define gmp_ctz(count, x) do { \ + mp_limb_t __ctz_x = (x); \ + unsigned __ctz_c = 0; \ + gmp_clz (__ctz_c, __ctz_x & - __ctz_x); \ + (count) = GMP_LIMB_BITS - 1 - __ctz_c; \ + } while (0) + +#define gmp_add_ssaaaa(sh, sl, ah, al, bh, bl) \ + do { \ + mp_limb_t __x; \ + __x = (al) + (bl); \ + (sh) = (ah) + (bh) + (__x < (al)); \ + (sl) = __x; \ + } while (0) + +#define gmp_sub_ddmmss(sh, sl, ah, al, bh, bl) \ + do { \ + mp_limb_t __x; \ + __x = (al) - (bl); \ + (sh) = (ah) - (bh) - ((al) < (bl)); \ + (sl) = __x; \ + } while (0) + +#define gmp_umul_ppmm(w1, w0, u, v) \ + do { \ + mp_limb_t __x0, __x1, __x2, __x3; \ + unsigned __ul, __vl, __uh, __vh; \ + mp_limb_t __u = (u), __v = (v); \ + \ + __ul = __u & GMP_LLIMB_MASK; \ + __uh = __u >> (GMP_LIMB_BITS / 2); \ + __vl = __v & GMP_LLIMB_MASK; \ + __vh = __v >> (GMP_LIMB_BITS / 2); \ + \ + __x0 = (mp_limb_t) __ul * __vl; \ + __x1 = (mp_limb_t) __ul * __vh; \ + __x2 = (mp_limb_t) __uh * __vl; \ + __x3 = (mp_limb_t) __uh * __vh; \ + \ + __x1 += __x0 >> (GMP_LIMB_BITS / 2);/* this can't give carry */ \ + __x1 += __x2; /* but this indeed can */ \ + if (__x1 < __x2) /* did we get it? */ \ + __x3 += GMP_HLIMB_BIT; /* yes, add it in the proper pos. */ \ + \ + (w1) = __x3 + (__x1 >> (GMP_LIMB_BITS / 2)); \ + (w0) = (__x1 << (GMP_LIMB_BITS / 2)) + (__x0 & GMP_LLIMB_MASK); \ + } while (0) + +#define gmp_udiv_qrnnd_preinv(q, r, nh, nl, d, di) \ + do { \ + mp_limb_t _qh, _ql, _r, _mask; \ + gmp_umul_ppmm (_qh, _ql, (nh), (di)); \ + gmp_add_ssaaaa (_qh, _ql, _qh, _ql, (nh) + 1, (nl)); \ + _r = (nl) - _qh * (d); \ + _mask = -(mp_limb_t) (_r > _ql); /* both > and >= are OK */ \ + _qh += _mask; \ + _r += _mask & (d); \ + if (_r >= (d)) \ + { \ + _r -= (d); \ + _qh++; \ + } \ + \ + (r) = _r; \ + (q) = _qh; \ + } while (0) + +#define gmp_udiv_qr_3by2(q, r1, r0, n2, n1, n0, d1, d0, dinv) \ + do { \ + mp_limb_t _q0, _t1, _t0, _mask; \ + gmp_umul_ppmm ((q), _q0, (n2), (dinv)); \ + gmp_add_ssaaaa ((q), _q0, (q), _q0, (n2), (n1)); \ + \ + /* Compute the two most significant limbs of n - q'd */ \ + (r1) = (n1) - (d1) * (q); \ + gmp_sub_ddmmss ((r1), (r0), (r1), (n0), (d1), (d0)); \ + gmp_umul_ppmm (_t1, _t0, (d0), (q)); \ + gmp_sub_ddmmss ((r1), (r0), (r1), (r0), _t1, _t0); \ + (q)++; \ + \ + /* Conditionally adjust q and the remainders */ \ + _mask = - (mp_limb_t) ((r1) >= _q0); \ + (q) += _mask; \ + gmp_add_ssaaaa ((r1), (r0), (r1), (r0), _mask & (d1), _mask & (d0)); \ + if ((r1) >= (d1)) \ + { \ + if ((r1) > (d1) || (r0) >= (d0)) \ + { \ + (q)++; \ + gmp_sub_ddmmss ((r1), (r0), (r1), (r0), (d1), (d0)); \ + } \ + } \ + } while (0) + +/* Swap macros. */ +#define MP_LIMB_T_SWAP(x, y) \ + do { \ + mp_limb_t __mp_limb_t_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mp_limb_t_swap__tmp; \ + } while (0) +#define MP_SIZE_T_SWAP(x, y) \ + do { \ + mp_size_t __mp_size_t_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mp_size_t_swap__tmp; \ + } while (0) +#define MP_BITCNT_T_SWAP(x,y) \ + do { \ + mp_bitcnt_t __mp_bitcnt_t_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mp_bitcnt_t_swap__tmp; \ + } while (0) +#define MP_PTR_SWAP(x, y) \ + do { \ + mp_ptr __mp_ptr_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mp_ptr_swap__tmp; \ + } while (0) +#define MP_SRCPTR_SWAP(x, y) \ + do { \ + mp_srcptr __mp_srcptr_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mp_srcptr_swap__tmp; \ + } while (0) + +#define MPN_PTR_SWAP(xp,xs, yp,ys) \ + do { \ + MP_PTR_SWAP (xp, yp); \ + MP_SIZE_T_SWAP (xs, ys); \ + } while(0) +#define MPN_SRCPTR_SWAP(xp,xs, yp,ys) \ + do { \ + MP_SRCPTR_SWAP (xp, yp); \ + MP_SIZE_T_SWAP (xs, ys); \ + } while(0) + +#define MPZ_PTR_SWAP(x, y) \ + do { \ + mpz_ptr __mpz_ptr_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mpz_ptr_swap__tmp; \ + } while (0) +#define MPZ_SRCPTR_SWAP(x, y) \ + do { \ + mpz_srcptr __mpz_srcptr_swap__tmp = (x); \ + (x) = (y); \ + (y) = __mpz_srcptr_swap__tmp; \ + } while (0) + +const int mp_bits_per_limb = GMP_LIMB_BITS; + + +/* Memory allocation and other helper functions. */ +static void +gmp_die (const char *msg) +{ + fprintf (stderr, "%s\n", msg); + abort(); +} + +static void * +gmp_default_alloc (size_t size) +{ + void *p; + + assert (size > 0); + + p = malloc (size); + if (!p) + gmp_die("gmp_default_alloc: Virtual memory exhausted."); + + return p; +} + +static void * +gmp_default_realloc (void *old, size_t old_size, size_t new_size) +{ + UN_USED(old_size); + + void * p; + + p = realloc (old, new_size); + + if (!p) + gmp_die("gmp_default_realloc: Virtual memory exhausted."); + + return p; +} + +static void +gmp_default_free (void *p, size_t size) +{ + UN_USED(size); + free (p); +} + +static void * (*gmp_allocate_func) (size_t) = gmp_default_alloc; +static void * (*gmp_reallocate_func) (void *, size_t, size_t) = gmp_default_realloc; +static void (*gmp_free_func) (void *, size_t) = gmp_default_free; + +void +mp_get_memory_functions (void *(**alloc_func) (size_t), + void *(**realloc_func) (void *, size_t, size_t), + void (**free_func) (void *, size_t)) +{ + if (alloc_func) + *alloc_func = gmp_allocate_func; + + if (realloc_func) + *realloc_func = gmp_reallocate_func; + + if (free_func) + *free_func = gmp_free_func; +} + +void +mp_set_memory_functions (void *(*alloc_func) (size_t), + void *(*realloc_func) (void *, size_t, size_t), + void (*free_func) (void *, size_t)) +{ + if (!alloc_func) + alloc_func = gmp_default_alloc; + if (!realloc_func) + realloc_func = gmp_default_realloc; + if (!free_func) + free_func = gmp_default_free; + + gmp_allocate_func = alloc_func; + gmp_reallocate_func = realloc_func; + gmp_free_func = free_func; +} + +#define gmp_xalloc(size) ((*gmp_allocate_func)((size))) +#define gmp_free(p) ((*gmp_free_func) ((p), 0)) + +static mp_ptr +gmp_xalloc_limbs (mp_size_t size) +{ + return (mp_ptr) gmp_xalloc (size * sizeof (mp_limb_t)); +} + +static mp_ptr +gmp_xrealloc_limbs (mp_ptr old, mp_size_t size) +{ + assert (size > 0); + return (mp_ptr) (*gmp_reallocate_func) (old, 0, size * sizeof (mp_limb_t)); +} + + +/* MPN interface */ + +void +mpn_copyi (mp_ptr d, mp_srcptr s, mp_size_t n) +{ + mp_size_t i; + for (i = 0; i < n; i++) + d[i] = s[i]; +} + +void +mpn_copyd (mp_ptr d, mp_srcptr s, mp_size_t n) +{ + while (--n >= 0) + d[n] = s[n]; +} + +int +mpn_cmp (mp_srcptr ap, mp_srcptr bp, mp_size_t n) +{ + while (--n >= 0) + { + if (ap[n] != bp[n]) + return ap[n] > bp[n] ? 1 : -1; + } + return 0; +} + +static int +mpn_cmp4 (mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn) +{ + if (an != bn) + return an < bn ? -1 : 1; + else + return mpn_cmp (ap, bp, an); +} + +static mp_size_t +mpn_normalized_size (mp_srcptr xp, mp_size_t n) +{ + while (n > 0 && xp[n-1] == 0) + --n; + return n; +} + +int +mpn_zero_p(mp_srcptr rp, mp_size_t n) +{ + return mpn_normalized_size (rp, n) == 0; +} + +void +mpn_zero (mp_ptr rp, mp_size_t n) +{ + while (--n >= 0) + rp[n] = 0; +} + +mp_limb_t +mpn_add_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b) +{ + mp_size_t i; + + assert (n > 0); + i = 0; + do + { + mp_limb_t r = ap[i] + b; + /* Carry out */ + b = (r < b); + rp[i] = r; + } + while (++i < n); + + return b; +} + +mp_limb_t +mpn_add_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n) +{ + mp_size_t i; + mp_limb_t cy; + + for (i = 0, cy = 0; i < n; i++) + { + mp_limb_t a, b, r; + a = ap[i]; b = bp[i]; + r = a + cy; + cy = (r < cy); + r += b; + cy += (r < b); + rp[i] = r; + } + return cy; +} + +mp_limb_t +mpn_add (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn) +{ + mp_limb_t cy; + + assert (an >= bn); + + cy = mpn_add_n (rp, ap, bp, bn); + if (an > bn) + cy = mpn_add_1 (rp + bn, ap + bn, an - bn, cy); + return cy; +} + +mp_limb_t +mpn_sub_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b) +{ + mp_size_t i; + + assert (n > 0); + + i = 0; + do + { + mp_limb_t a = ap[i]; + /* Carry out */ + mp_limb_t cy = a < b; + rp[i] = a - b; + b = cy; + } + while (++i < n); + + return b; +} + +mp_limb_t +mpn_sub_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n) +{ + mp_size_t i; + mp_limb_t cy; + + for (i = 0, cy = 0; i < n; i++) + { + mp_limb_t a, b; + a = ap[i]; b = bp[i]; + b += cy; + cy = (b < cy); + cy += (a < b); + rp[i] = a - b; + } + return cy; +} + +mp_limb_t +mpn_sub (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn) +{ + mp_limb_t cy; + + assert (an >= bn); + + cy = mpn_sub_n (rp, ap, bp, bn); + if (an > bn) + cy = mpn_sub_1 (rp + bn, ap + bn, an - bn, cy); + return cy; +} + +mp_limb_t +mpn_mul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl) +{ + mp_limb_t ul, cl, hpl, lpl; + + assert (n >= 1); + + cl = 0; + do + { + ul = *up++; + gmp_umul_ppmm (hpl, lpl, ul, vl); + + lpl += cl; + cl = (lpl < cl) + hpl; + + *rp++ = lpl; + } + while (--n != 0); + + return cl; +} + +mp_limb_t +mpn_addmul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl) +{ + mp_limb_t ul, cl, hpl, lpl, rl; + + assert (n >= 1); + + cl = 0; + do + { + ul = *up++; + gmp_umul_ppmm (hpl, lpl, ul, vl); + + lpl += cl; + cl = (lpl < cl) + hpl; + + rl = *rp; + lpl = rl + lpl; + cl += lpl < rl; + *rp++ = lpl; + } + while (--n != 0); + + return cl; +} + +mp_limb_t +mpn_submul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl) +{ + mp_limb_t ul, cl, hpl, lpl, rl; + + assert (n >= 1); + + cl = 0; + do + { + ul = *up++; + gmp_umul_ppmm (hpl, lpl, ul, vl); + + lpl += cl; + cl = (lpl < cl) + hpl; + + rl = *rp; + lpl = rl - lpl; + cl += lpl > rl; + *rp++ = lpl; + } + while (--n != 0); + + return cl; +} + +mp_limb_t +mpn_mul (mp_ptr rp, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn) +{ + assert (un >= vn); + assert (vn >= 1); + + /* We first multiply by the low order limb. This result can be + stored, not added, to rp. We also avoid a loop for zeroing this + way. */ + + rp[un] = mpn_mul_1 (rp, up, un, vp[0]); + + /* Now accumulate the product of up[] and the next higher limb from + vp[]. */ + + while (--vn >= 1) + { + rp += 1, vp += 1; + rp[un] = mpn_addmul_1 (rp, up, un, vp[0]); + } + return rp[un]; +} + +void +mpn_mul_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n) +{ + mpn_mul (rp, ap, n, bp, n); +} + +void +mpn_sqr (mp_ptr rp, mp_srcptr ap, mp_size_t n) +{ + mpn_mul (rp, ap, n, ap, n); +} + +mp_limb_t +mpn_lshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt) +{ + mp_limb_t high_limb, low_limb; + unsigned int tnc; + mp_limb_t retval; + + assert (n >= 1); + assert (cnt >= 1); + assert (cnt < GMP_LIMB_BITS); + + up += n; + rp += n; + + tnc = GMP_LIMB_BITS - cnt; + low_limb = *--up; + retval = low_limb >> tnc; + high_limb = (low_limb << cnt); + + while (--n != 0) + { + low_limb = *--up; + *--rp = high_limb | (low_limb >> tnc); + high_limb = (low_limb << cnt); + } + *--rp = high_limb; + + return retval; +} + +mp_limb_t +mpn_rshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt) +{ + mp_limb_t high_limb, low_limb; + unsigned int tnc; + mp_limb_t retval; + + assert (n >= 1); + assert (cnt >= 1); + assert (cnt < GMP_LIMB_BITS); + + tnc = GMP_LIMB_BITS - cnt; + high_limb = *up++; + retval = (high_limb << tnc); + low_limb = high_limb >> cnt; + + while (--n != 0) + { + high_limb = *up++; + *rp++ = low_limb | (high_limb << tnc); + low_limb = high_limb >> cnt; + } + *rp = low_limb; + + return retval; +} + +static mp_bitcnt_t +mpn_common_scan (mp_limb_t limb, mp_size_t i, mp_srcptr up, mp_size_t un, + mp_limb_t ux) +{ + unsigned cnt; + + assert (ux == 0 || ux == GMP_LIMB_MAX); + assert (0 <= i && i <= un ); + + while (limb == 0) + { + i++; + if (i == un) + return (ux == 0 ? ~(mp_bitcnt_t) 0 : un * GMP_LIMB_BITS); + limb = ux ^ up[i]; + } + gmp_ctz (cnt, limb); + return (mp_bitcnt_t) i * GMP_LIMB_BITS + cnt; +} + +mp_bitcnt_t +mpn_scan1 (mp_srcptr ptr, mp_bitcnt_t bit) +{ + mp_size_t i; + i = bit / GMP_LIMB_BITS; + + return mpn_common_scan ( ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)), + i, ptr, i, 0); +} + +mp_bitcnt_t +mpn_scan0 (mp_srcptr ptr, mp_bitcnt_t bit) +{ + mp_size_t i; + i = bit / GMP_LIMB_BITS; + + return mpn_common_scan (~ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)), + i, ptr, i, GMP_LIMB_MAX); +} + +void +mpn_com (mp_ptr rp, mp_srcptr up, mp_size_t n) +{ + while (--n >= 0) + *rp++ = ~ *up++; +} + +mp_limb_t +mpn_neg (mp_ptr rp, mp_srcptr up, mp_size_t n) +{ + while (*up == 0) + { + *rp = 0; + if (!--n) + return 0; + ++up; ++rp; + } + *rp = - *up; + mpn_com (++rp, ++up, --n); + return 1; +} + + +/* MPN division interface. */ + +/* The 3/2 inverse is defined as + + m = floor( (B^3-1) / (B u1 + u0)) - B +*/ +mp_limb_t +mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0) +{ + mp_limb_t r, p, m, ql; + unsigned ul, uh, qh; + + assert (u1 >= GMP_LIMB_HIGHBIT); + + /* For notation, let b denote the half-limb base, so that B = b^2. + Split u1 = b uh + ul. */ + ul = u1 & GMP_LLIMB_MASK; + uh = u1 >> (GMP_LIMB_BITS / 2); + + /* Approximation of the high half of quotient. Differs from the 2/1 + inverse of the half limb uh, since we have already subtracted + u0. */ + qh = ~u1 / uh; + + /* Adjust to get a half-limb 3/2 inverse, i.e., we want + + qh' = floor( (b^3 - 1) / u) - b = floor ((b^3 - b u - 1) / u + = floor( (b (~u) + b-1) / u), + + and the remainder + + r = b (~u) + b-1 - qh (b uh + ul) + = b (~u - qh uh) + b-1 - qh ul + + Subtraction of qh ul may underflow, which implies adjustments. + But by normalization, 2 u >= B > qh ul, so we need to adjust by + at most 2. + */ + + r = ((~u1 - (mp_limb_t) qh * uh) << (GMP_LIMB_BITS / 2)) | GMP_LLIMB_MASK; + + p = (mp_limb_t) qh * ul; + /* Adjustment steps taken from udiv_qrnnd_c */ + if (r < p) + { + qh--; + r += u1; + if (r >= u1) /* i.e. we didn't get carry when adding to r */ + if (r < p) + { + qh--; + r += u1; + } + } + r -= p; + + /* Low half of the quotient is + + ql = floor ( (b r + b-1) / u1). + + This is a 3/2 division (on half-limbs), for which qh is a + suitable inverse. */ + + p = (r >> (GMP_LIMB_BITS / 2)) * qh + r; + /* Unlike full-limb 3/2, we can add 1 without overflow. For this to + work, it is essential that ql is a full mp_limb_t. */ + ql = (p >> (GMP_LIMB_BITS / 2)) + 1; + + /* By the 3/2 trick, we don't need the high half limb. */ + r = (r << (GMP_LIMB_BITS / 2)) + GMP_LLIMB_MASK - ql * u1; + + if (r >= (p << (GMP_LIMB_BITS / 2))) + { + ql--; + r += u1; + } + m = ((mp_limb_t) qh << (GMP_LIMB_BITS / 2)) + ql; + if (r >= u1) + { + m++; + r -= u1; + } + + /* Now m is the 2/1 invers of u1. If u0 > 0, adjust it to become a + 3/2 inverse. */ + if (u0 > 0) + { + mp_limb_t th, tl; + r = ~r; + r += u0; + if (r < u0) + { + m--; + if (r >= u1) + { + m--; + r -= u1; + } + r -= u1; + } + gmp_umul_ppmm (th, tl, u0, m); + r += th; + if (r < th) + { + m--; + m -= ((r > u1) | ((r == u1) & (tl > u0))); + } + } + + return m; +} + +struct gmp_div_inverse +{ + /* Normalization shift count. */ + unsigned shift; + /* Normalized divisor (d0 unused for mpn_div_qr_1) */ + mp_limb_t d1, d0; + /* Inverse, for 2/1 or 3/2. */ + mp_limb_t di; +}; + +static void +mpn_div_qr_1_invert (struct gmp_div_inverse *inv, mp_limb_t d) +{ + unsigned shift; + + assert (d > 0); + gmp_clz (shift, d); + inv->shift = shift; + inv->d1 = d << shift; + inv->di = mpn_invert_limb (inv->d1); +} + +static void +mpn_div_qr_2_invert (struct gmp_div_inverse *inv, + mp_limb_t d1, mp_limb_t d0) +{ + unsigned shift; + + assert (d1 > 0); + gmp_clz (shift, d1); + inv->shift = shift; + if (shift > 0) + { + d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift)); + d0 <<= shift; + } + inv->d1 = d1; + inv->d0 = d0; + inv->di = mpn_invert_3by2 (d1, d0); +} + +static void +mpn_div_qr_invert (struct gmp_div_inverse *inv, + mp_srcptr dp, mp_size_t dn) +{ + assert (dn > 0); + + if (dn == 1) + mpn_div_qr_1_invert (inv, dp[0]); + else if (dn == 2) + mpn_div_qr_2_invert (inv, dp[1], dp[0]); + else + { + unsigned shift; + mp_limb_t d1, d0; + + d1 = dp[dn-1]; + d0 = dp[dn-2]; + assert (d1 > 0); + gmp_clz (shift, d1); + inv->shift = shift; + if (shift > 0) + { + d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift)); + d0 = (d0 << shift) | (dp[dn-3] >> (GMP_LIMB_BITS - shift)); + } + inv->d1 = d1; + inv->d0 = d0; + inv->di = mpn_invert_3by2 (d1, d0); + } +} + +/* Not matching current public gmp interface, rather corresponding to + the sbpi1_div_* functions. */ +static mp_limb_t +mpn_div_qr_1_preinv (mp_ptr qp, mp_srcptr np, mp_size_t nn, + const struct gmp_div_inverse *inv) +{ + mp_limb_t d, di; + mp_limb_t r; + mp_ptr tp = NULL; + + if (inv->shift > 0) + { + tp = gmp_xalloc_limbs (nn); + r = mpn_lshift (tp, np, nn, inv->shift); + np = tp; + } + else + r = 0; + + d = inv->d1; + di = inv->di; + while (--nn >= 0) + { + mp_limb_t q; + + gmp_udiv_qrnnd_preinv (q, r, r, np[nn], d, di); + if (qp) + qp[nn] = q; + } + if (inv->shift > 0) + gmp_free (tp); + + return r >> inv->shift; +} + +static mp_limb_t +mpn_div_qr_1 (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_limb_t d) +{ + assert (d > 0); + + /* Special case for powers of two. */ + if ((d & (d-1)) == 0) + { + mp_limb_t r = np[0] & (d-1); + if (qp) + { + if (d <= 1) + mpn_copyi (qp, np, nn); + else + { + unsigned shift; + gmp_ctz (shift, d); + mpn_rshift (qp, np, nn, shift); + } + } + return r; + } + else + { + struct gmp_div_inverse inv; + mpn_div_qr_1_invert (&inv, d); + return mpn_div_qr_1_preinv (qp, np, nn, &inv); + } +} + +static void +mpn_div_qr_2_preinv (mp_ptr qp, mp_ptr rp, mp_srcptr np, mp_size_t nn, + const struct gmp_div_inverse *inv) +{ + unsigned shift; + mp_size_t i; + mp_limb_t d1, d0, di, r1, r0; + mp_ptr tp; + + assert (nn >= 2); + shift = inv->shift; + d1 = inv->d1; + d0 = inv->d0; + di = inv->di; + + if (shift > 0) + { + tp = gmp_xalloc_limbs (nn); + r1 = mpn_lshift (tp, np, nn, shift); + np = tp; + } + else + r1 = 0; + + r0 = np[nn - 1]; + + i = nn - 2; + do + { + mp_limb_t n0, q; + n0 = np[i]; + gmp_udiv_qr_3by2 (q, r1, r0, r1, r0, n0, d1, d0, di); + + if (qp) + qp[i] = q; + } + while (--i >= 0); + + if (shift > 0) + { + assert ((r0 << (GMP_LIMB_BITS - shift)) == 0); + r0 = (r0 >> shift) | (r1 << (GMP_LIMB_BITS - shift)); + r1 >>= shift; + + gmp_free (tp); + } + + rp[1] = r1; + rp[0] = r0; +} + +#if 0 +static void +mpn_div_qr_2 (mp_ptr qp, mp_ptr rp, mp_srcptr np, mp_size_t nn, + mp_limb_t d1, mp_limb_t d0) +{ + struct gmp_div_inverse inv; + assert (nn >= 2); + + mpn_div_qr_2_invert (&inv, d1, d0); + mpn_div_qr_2_preinv (qp, rp, np, nn, &inv); +} +#endif + +static void +mpn_div_qr_pi1 (mp_ptr qp, + mp_ptr np, mp_size_t nn, mp_limb_t n1, + mp_srcptr dp, mp_size_t dn, + mp_limb_t dinv) +{ + mp_size_t i; + + mp_limb_t d1, d0; + mp_limb_t cy, cy1; + mp_limb_t q; + + assert (dn > 2); + assert (nn >= dn); + + d1 = dp[dn - 1]; + d0 = dp[dn - 2]; + + assert ((d1 & GMP_LIMB_HIGHBIT) != 0); + /* Iteration variable is the index of the q limb. + * + * We divide + * by + */ + + i = nn - dn; + do + { + mp_limb_t n0 = np[dn-1+i]; + + if (n1 == d1 && n0 == d0) + { + q = GMP_LIMB_MAX; + mpn_submul_1 (np+i, dp, dn, q); + n1 = np[dn-1+i]; /* update n1, last loop's value will now be invalid */ + } + else + { + gmp_udiv_qr_3by2 (q, n1, n0, n1, n0, np[dn-2+i], d1, d0, dinv); + + cy = mpn_submul_1 (np + i, dp, dn-2, q); + + cy1 = n0 < cy; + n0 = n0 - cy; + cy = n1 < cy1; + n1 = n1 - cy1; + np[dn-2+i] = n0; + + if (cy != 0) + { + n1 += d1 + mpn_add_n (np + i, np + i, dp, dn - 1); + q--; + } + } + + if (qp) + qp[i] = q; + } + while (--i >= 0); + + np[dn - 1] = n1; +} + +static void +mpn_div_qr_preinv (mp_ptr qp, mp_ptr np, mp_size_t nn, + mp_srcptr dp, mp_size_t dn, + const struct gmp_div_inverse *inv) +{ + assert (dn > 0); + assert (nn >= dn); + + if (dn == 1) + np[0] = mpn_div_qr_1_preinv (qp, np, nn, inv); + else if (dn == 2) + mpn_div_qr_2_preinv (qp, np, np, nn, inv); + else + { + mp_limb_t nh; + unsigned shift; + + assert (inv->d1 == dp[dn-1]); + assert (inv->d0 == dp[dn-2]); + assert ((inv->d1 & GMP_LIMB_HIGHBIT) != 0); + + shift = inv->shift; + if (shift > 0) + nh = mpn_lshift (np, np, nn, shift); + else + nh = 0; + + mpn_div_qr_pi1 (qp, np, nn, nh, dp, dn, inv->di); + + if (shift > 0) + gmp_assert_nocarry (mpn_rshift (np, np, dn, shift)); + } +} + +static void +mpn_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn) +{ + struct gmp_div_inverse inv; + mp_ptr tp = NULL; + + assert (dn > 0); + assert (nn >= dn); + + mpn_div_qr_invert (&inv, dp, dn); + if (dn > 2 && inv.shift > 0) + { + tp = gmp_xalloc_limbs (dn); + gmp_assert_nocarry (mpn_lshift (tp, dp, dn, inv.shift)); + dp = tp; + } + mpn_div_qr_preinv (qp, np, nn, dp, dn, &inv); + if (tp) + gmp_free (tp); +} + + +/* MPN base conversion. */ +static unsigned +mpn_base_power_of_two_p (unsigned b) +{ + switch (b) + { + case 2: return 1; + case 4: return 2; + case 8: return 3; + case 16: return 4; + case 32: return 5; + case 64: return 6; + case 128: return 7; + case 256: return 8; + default: return 0; + } +} + +struct mpn_base_info +{ + /* bb is the largest power of the base which fits in one limb, and + exp is the corresponding exponent. */ + unsigned exp; + mp_limb_t bb; +}; + +static void +mpn_get_base_info (struct mpn_base_info *info, mp_limb_t b) +{ + mp_limb_t m; + mp_limb_t p; + unsigned exp; + + m = GMP_LIMB_MAX / b; + for (exp = 1, p = b; p <= m; exp++) + p *= b; + + info->exp = exp; + info->bb = p; +} + +static mp_bitcnt_t +mpn_limb_size_in_base_2 (mp_limb_t u) +{ + unsigned shift; + + assert (u > 0); + gmp_clz (shift, u); + return GMP_LIMB_BITS - shift; +} + +static size_t +mpn_get_str_bits (unsigned char *sp, unsigned bits, mp_srcptr up, mp_size_t un) +{ + unsigned char mask; + size_t sn, j; + mp_size_t i; + unsigned shift; + + sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1]) + + bits - 1) / bits; + + mask = (1U << bits) - 1; + + for (i = 0, j = sn, shift = 0; j-- > 0;) + { + unsigned char digit = up[i] >> shift; + + shift += bits; + + if (shift >= GMP_LIMB_BITS && ++i < un) + { + shift -= GMP_LIMB_BITS; + digit |= up[i] << (bits - shift); + } + sp[j] = digit & mask; + } + return sn; +} + +/* We generate digits from the least significant end, and reverse at + the end. */ +static size_t +mpn_limb_get_str (unsigned char *sp, mp_limb_t w, + const struct gmp_div_inverse *binv) +{ + mp_size_t i; + for (i = 0; w > 0; i++) + { + mp_limb_t h, l, r; + + h = w >> (GMP_LIMB_BITS - binv->shift); + l = w << binv->shift; + + gmp_udiv_qrnnd_preinv (w, r, h, l, binv->d1, binv->di); + assert ( (r << (GMP_LIMB_BITS - binv->shift)) == 0); + r >>= binv->shift; + + sp[i] = r; + } + return i; +} + +static size_t +mpn_get_str_other (unsigned char *sp, + int base, const struct mpn_base_info *info, + mp_ptr up, mp_size_t un) +{ + struct gmp_div_inverse binv; + size_t sn; + size_t i; + + mpn_div_qr_1_invert (&binv, base); + + sn = 0; + + if (un > 1) + { + struct gmp_div_inverse bbinv; + mpn_div_qr_1_invert (&bbinv, info->bb); + + do + { + mp_limb_t w; + size_t done; + w = mpn_div_qr_1_preinv (up, up, un, &bbinv); + un -= (up[un-1] == 0); + done = mpn_limb_get_str (sp + sn, w, &binv); + + for (sn += done; done < info->exp; done++) + sp[sn++] = 0; + } + while (un > 1); + } + sn += mpn_limb_get_str (sp + sn, up[0], &binv); + + /* Reverse order */ + for (i = 0; 2*i + 1 < sn; i++) + { + unsigned char t = sp[i]; + sp[i] = sp[sn - i - 1]; + sp[sn - i - 1] = t; + } + + return sn; +} + +size_t +mpn_get_str (unsigned char *sp, int base, mp_ptr up, mp_size_t un) +{ + unsigned bits; + + assert (un > 0); + assert (up[un-1] > 0); + + bits = mpn_base_power_of_two_p (base); + if (bits) + return mpn_get_str_bits (sp, bits, up, un); + else + { + struct mpn_base_info info; + + mpn_get_base_info (&info, base); + return mpn_get_str_other (sp, base, &info, up, un); + } +} + +static mp_size_t +mpn_set_str_bits (mp_ptr rp, const unsigned char *sp, size_t sn, + unsigned bits) +{ + mp_size_t rn; + size_t j; + unsigned shift; + + for (j = sn, rn = 0, shift = 0; j-- > 0; ) + { + if (shift == 0) + { + rp[rn++] = sp[j]; + shift += bits; + } + else + { + rp[rn-1] |= (mp_limb_t) sp[j] << shift; + shift += bits; + if (shift >= GMP_LIMB_BITS) + { + shift -= GMP_LIMB_BITS; + if (shift > 0) + rp[rn++] = (mp_limb_t) sp[j] >> (bits - shift); + } + } + } + rn = mpn_normalized_size (rp, rn); + return rn; +} + +/* Result is usually normalized, except for all-zero input, in which + case a single zero limb is written at *RP, and 1 is returned. */ +static mp_size_t +mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn, + mp_limb_t b, const struct mpn_base_info *info) +{ + mp_size_t rn; + mp_limb_t w; + unsigned k; + size_t j; + + assert (sn > 0); + + k = 1 + (sn - 1) % info->exp; + + j = 0; + w = sp[j++]; + while (--k != 0) + w = w * b + sp[j++]; + + rp[0] = w; + + for (rn = 1; j < sn;) + { + mp_limb_t cy; + + w = sp[j++]; + for (k = 1; k < info->exp; k++) + w = w * b + sp[j++]; + + cy = mpn_mul_1 (rp, rp, rn, info->bb); + cy += mpn_add_1 (rp, rp, rn, w); + if (cy > 0) + rp[rn++] = cy; + } + assert (j == sn); + + return rn; +} + +mp_size_t +mpn_set_str (mp_ptr rp, const unsigned char *sp, size_t sn, int base) +{ + unsigned bits; + + if (sn == 0) + return 0; + + bits = mpn_base_power_of_two_p (base); + if (bits) + return mpn_set_str_bits (rp, sp, sn, bits); + else + { + struct mpn_base_info info; + + mpn_get_base_info (&info, base); + return mpn_set_str_other (rp, sp, sn, base, &info); + } +} + + +/* MPZ interface */ +void +mpz_init (mpz_t r) +{ + static const mp_limb_t dummy_limb = 0xc1a0; + + r->_mp_alloc = 0; + r->_mp_size = 0; + r->_mp_d = (mp_ptr) &dummy_limb; +} + +/* The utility of this function is a bit limited, since many functions + assigns the result variable using mpz_swap. */ +void +mpz_init2 (mpz_t r, mp_bitcnt_t bits) +{ + mp_size_t rn; + + bits -= (bits != 0); /* Round down, except if 0 */ + rn = 1 + bits / GMP_LIMB_BITS; + + r->_mp_alloc = rn; + r->_mp_size = 0; + r->_mp_d = gmp_xalloc_limbs (rn); +} + +void +mpz_clear (mpz_t r) +{ + if (r->_mp_alloc) + gmp_free (r->_mp_d); +} + +static mp_ptr +mpz_realloc (mpz_t r, mp_size_t size) +{ + size = GMP_MAX (size, 1); + + if (r->_mp_alloc) + r->_mp_d = gmp_xrealloc_limbs (r->_mp_d, size); + else + r->_mp_d = gmp_xalloc_limbs (size); + r->_mp_alloc = size; + + if (GMP_ABS (r->_mp_size) > size) + r->_mp_size = 0; + + return r->_mp_d; +} + +/* Realloc for an mpz_t WHAT if it has less than NEEDED limbs. */ +#define MPZ_REALLOC(z,n) ((n) > (z)->_mp_alloc \ + ? mpz_realloc(z,n) \ + : (z)->_mp_d) + +/* MPZ assignment and basic conversions. */ +void +mpz_set_si (mpz_t r, intMpz x) +{ + if (x >= 0) + mpz_set_ui (r, x); + else /* (x < 0) */ + { + r->_mp_size = -1; + MPZ_REALLOC (r, 1)[0] = GMP_NEG_CAST (uIntMpz, x); + } +} + +void +mpz_set_ui (mpz_t r, uIntMpz x) +{ + if (x > 0) + { + r->_mp_size = 1; + MPZ_REALLOC (r, 1)[0] = x; + } + else + r->_mp_size = 0; +} + +void +mpz_set (mpz_t r, const mpz_t x) +{ + /* Allow the NOP r == x */ + if (r != x) + { + mp_size_t n; + mp_ptr rp; + + n = GMP_ABS (x->_mp_size); + rp = MPZ_REALLOC (r, n); + + mpn_copyi (rp, x->_mp_d, n); + r->_mp_size = x->_mp_size; + } +} + +void +mpz_init_set_si (mpz_t r, intMpz x) +{ + mpz_init (r); + mpz_set_si (r, x); +} + +void +mpz_init_set_ui (mpz_t r, uIntMpz x) +{ + mpz_init (r); + mpz_set_ui (r, x); +} + +void +mpz_init_set (mpz_t r, const mpz_t x) +{ + mpz_init (r); + mpz_set (r, x); +} + +int +mpz_fits_slong_p (const mpz_t u) +{ + mp_size_t us = u->_mp_size; + + if (us == 1) + return u->_mp_d[0] < GMP_LIMB_HIGHBIT; + else if (us == -1) + return u->_mp_d[0] <= GMP_LIMB_HIGHBIT; + else + return (us == 0); +} + +int +mpz_fits_ulong_p (const mpz_t u) +{ + mp_size_t us = u->_mp_size; + + return (us == (us > 0)); +} + + intMpz +mpz_get_si (const mpz_t u) +{ + if (u->_mp_size < 0) + /* This expression is necessary to properly handle 0x80000000 */ + return -1 - (long) ((u->_mp_d[0] - 1) & ~GMP_LIMB_HIGHBIT); + else + return (long) (mpz_get_ui (u) & ~GMP_LIMB_HIGHBIT); +} + +uIntMpz +mpz_get_ui (const mpz_t u) +{ + return u->_mp_size == 0 ? 0 : u->_mp_d[0]; +} + +size_t +mpz_size (const mpz_t u) +{ + return GMP_ABS (u->_mp_size); +} + +mp_limb_t +mpz_getlimbn (const mpz_t u, mp_size_t n) +{ + if (n >= 0 && n < GMP_ABS (u->_mp_size)) + return u->_mp_d[n]; + else + return 0; +} + +void +mpz_realloc2 (mpz_t x, mp_bitcnt_t n) +{ + mpz_realloc (x, 1 + (n - (n != 0)) / GMP_LIMB_BITS); +} + +mp_srcptr +mpz_limbs_read (mpz_srcptr x) +{ + return x->_mp_d; +} + +mp_ptr +mpz_limbs_modify (mpz_t x, mp_size_t n) +{ + assert (n > 0); + return MPZ_REALLOC (x, n); +} + +mp_ptr +mpz_limbs_write (mpz_t x, mp_size_t n) +{ + return mpz_limbs_modify (x, n); +} + +void +mpz_limbs_finish (mpz_t x, mp_size_t xs) +{ + mp_size_t xn; + xn = mpn_normalized_size (x->_mp_d, GMP_ABS (xs)); + x->_mp_size = xs < 0 ? -xn : xn; +} + +mpz_srcptr +mpz_roinit_n (mpz_t x, mp_srcptr xp, mp_size_t xs) +{ + x->_mp_alloc = 0; + x->_mp_d = (mp_ptr) xp; + mpz_limbs_finish (x, xs); + return x; +} + + +/* Conversions and comparison to double. */ +void +mpz_set_d (mpz_t r, double x) +{ + int sign; + mp_ptr rp; + mp_size_t rn, i; + double B; + double Bi; + mp_limb_t f; + + /* x != x is true when x is a NaN, and x == x * 0.5 is true when x is + zero or infinity. */ + if (x != x || x == x * 0.5) + { + r->_mp_size = 0; + return; + } + + sign = x < 0.0 ; + if (sign) + x = - x; + + if (x < 1.0) + { + r->_mp_size = 0; + return; + } + B = 2.0 * (double) GMP_LIMB_HIGHBIT; + Bi = 1.0 / B; + for (rn = 1; x >= B; rn++) + x *= Bi; + + rp = MPZ_REALLOC (r, rn); + + f = (mp_limb_t) x; + x -= f; + assert (x < 1.0); + i = rn-1; + rp[i] = f; + while (--i >= 0) + { + x = B * x; + f = (mp_limb_t) x; + x -= f; + assert (x < 1.0); + rp[i] = f; + } + + r->_mp_size = sign ? - rn : rn; +} + +void +mpz_init_set_d (mpz_t r, double x) +{ + mpz_init (r); + mpz_set_d (r, x); +} + +double +mpz_get_d (const mpz_t u) +{ + mp_size_t un; + double x; + double B = 2.0 * (double) GMP_LIMB_HIGHBIT; + + un = GMP_ABS (u->_mp_size); + + if (un == 0) + return 0.0; + + x = u->_mp_d[--un]; + while (un > 0) + x = B*x + u->_mp_d[--un]; + + if (u->_mp_size < 0) + x = -x; + + return x; +} + +int +mpz_cmpabs_d (const mpz_t x, double d) +{ + mp_size_t xn; + double B, Bi; + mp_size_t i; + + xn = x->_mp_size; + d = GMP_ABS (d); + + if (xn != 0) + { + xn = GMP_ABS (xn); + + B = 2.0 * (double) GMP_LIMB_HIGHBIT; + Bi = 1.0 / B; + + /* Scale d so it can be compared with the top limb. */ + for (i = 1; i < xn; i++) + d *= Bi; + + if (d >= B) + return -1; + + /* Compare floor(d) to top limb, subtract and cancel when equal. */ + for (i = xn; i-- > 0;) + { + mp_limb_t f, xl; + + f = (mp_limb_t) d; + xl = x->_mp_d[i]; + if (xl > f) + return 1; + else if (xl < f) + return -1; + d = B * (d - f); + } + } + return - (d > 0.0); +} + +int +mpz_cmp_d (const mpz_t x, double d) +{ + if (x->_mp_size < 0) + { + if (d >= 0.0) + return -1; + else + return -mpz_cmpabs_d (x, d); + } + else + { + if (d < 0.0) + return 1; + else + return mpz_cmpabs_d (x, d); + } +} + + +/* MPZ comparisons and the like. */ +int +mpz_sgn (const mpz_t u) +{ + return GMP_CMP (u->_mp_size, 0); +} + +int +mpz_cmp_si (const mpz_t u, intMpz v) +{ + mp_size_t usize = u->_mp_size; + + if (usize < -1) + return -1; + else if (v >= 0) + return mpz_cmp_ui (u, v); + else if (usize >= 0) + return 1; + else /* usize == -1 */ + return GMP_CMP (GMP_NEG_CAST (mp_limb_t, v), u->_mp_d[0]); +} + +int +mpz_cmp_ui (const mpz_t u, uIntMpz v) +{ + mp_size_t usize = u->_mp_size; + + if (usize > 1) + return 1; + else if (usize < 0) + return -1; + else + return GMP_CMP (mpz_get_ui (u), v); +} + +int +mpz_cmp (const mpz_t a, const mpz_t b) +{ + mp_size_t asize = a->_mp_size; + mp_size_t bsize = b->_mp_size; + + if (asize != bsize) + return (asize < bsize) ? -1 : 1; + else if (asize >= 0) + return mpn_cmp (a->_mp_d, b->_mp_d, asize); + else + return mpn_cmp (b->_mp_d, a->_mp_d, -asize); +} + +int +mpz_cmpabs_ui (const mpz_t u, uIntMpz v) +{ + if (GMP_ABS (u->_mp_size) > 1) + return 1; + else + return GMP_CMP (mpz_get_ui (u), v); +} + +int +mpz_cmpabs (const mpz_t u, const mpz_t v) +{ + return mpn_cmp4 (u->_mp_d, GMP_ABS (u->_mp_size), + v->_mp_d, GMP_ABS (v->_mp_size)); +} + +void +mpz_abs (mpz_t r, const mpz_t u) +{ + mpz_set (r, u); + r->_mp_size = GMP_ABS (r->_mp_size); +} + +void +mpz_neg (mpz_t r, const mpz_t u) +{ + mpz_set (r, u); + r->_mp_size = -r->_mp_size; +} + +void +mpz_swap (mpz_t u, mpz_t v) +{ + MP_SIZE_T_SWAP (u->_mp_size, v->_mp_size); + MP_SIZE_T_SWAP (u->_mp_alloc, v->_mp_alloc); + MP_PTR_SWAP (u->_mp_d, v->_mp_d); +} + + +/* MPZ addition and subtraction */ + +/* Adds to the absolute value. Returns new size, but doesn't store it. */ +static mp_size_t +mpz_abs_add_ui (mpz_t r, const mpz_t a, uIntMpz b) +{ + mp_size_t an; + mp_ptr rp; + mp_limb_t cy; + + an = GMP_ABS (a->_mp_size); + if (an == 0) + { + MPZ_REALLOC (r, 1)[0] = b; + return b > 0; + } + + rp = MPZ_REALLOC (r, an + 1); + + cy = mpn_add_1 (rp, a->_mp_d, an, b); + rp[an] = cy; + an += cy; + + return an; +} + +/* Subtract from the absolute value. Returns new size, (or -1 on underflow), + but doesn't store it. */ +static mp_size_t +mpz_abs_sub_ui (mpz_t r, const mpz_t a, uIntMpz b) +{ + mp_size_t an = GMP_ABS (a->_mp_size); + mp_ptr rp; + + if (an == 0) + { + MPZ_REALLOC (r, 1)[0] = b; + return -(b > 0); + } + rp = MPZ_REALLOC (r, an); + if (an == 1 && a->_mp_d[0] < b) + { + rp[0] = b - a->_mp_d[0]; + return -1; + } + else + { + gmp_assert_nocarry (mpn_sub_1 (rp, a->_mp_d, an, b)); + return mpn_normalized_size (rp, an); + } +} + +void +mpz_add_ui (mpz_t r, const mpz_t a, uIntMpz b) +{ + if (a->_mp_size >= 0) + r->_mp_size = mpz_abs_add_ui (r, a, b); + else + r->_mp_size = -mpz_abs_sub_ui (r, a, b); +} + +void +mpz_sub_ui (mpz_t r, const mpz_t a, uIntMpz b) +{ + if (a->_mp_size < 0) + r->_mp_size = -mpz_abs_add_ui (r, a, b); + else + r->_mp_size = mpz_abs_sub_ui (r, a, b); +} + +void +mpz_ui_sub (mpz_t r, uIntMpz a, const mpz_t b) +{ + if (b->_mp_size < 0) + r->_mp_size = mpz_abs_add_ui (r, b, a); + else + r->_mp_size = -mpz_abs_sub_ui (r, b, a); +} + +static mp_size_t +mpz_abs_add (mpz_t r, const mpz_t a, const mpz_t b) +{ + mp_size_t an = GMP_ABS (a->_mp_size); + mp_size_t bn = GMP_ABS (b->_mp_size); + mp_ptr rp; + mp_limb_t cy; + + if (an < bn) + { + MPZ_SRCPTR_SWAP (a, b); + MP_SIZE_T_SWAP (an, bn); + } + + rp = MPZ_REALLOC (r, an + 1); + cy = mpn_add (rp, a->_mp_d, an, b->_mp_d, bn); + + rp[an] = cy; + + return an + cy; +} + +static mp_size_t +mpz_abs_sub (mpz_t r, const mpz_t a, const mpz_t b) +{ + mp_size_t an = GMP_ABS (a->_mp_size); + mp_size_t bn = GMP_ABS (b->_mp_size); + int cmp; + mp_ptr rp; + + cmp = mpn_cmp4 (a->_mp_d, an, b->_mp_d, bn); + if (cmp > 0) + { + rp = MPZ_REALLOC (r, an); + gmp_assert_nocarry (mpn_sub (rp, a->_mp_d, an, b->_mp_d, bn)); + return mpn_normalized_size (rp, an); + } + else if (cmp < 0) + { + rp = MPZ_REALLOC (r, bn); + gmp_assert_nocarry (mpn_sub (rp, b->_mp_d, bn, a->_mp_d, an)); + return -mpn_normalized_size (rp, bn); + } + else + return 0; +} + +void +mpz_add (mpz_t r, const mpz_t a, const mpz_t b) +{ + mp_size_t rn; + + if ( (a->_mp_size ^ b->_mp_size) >= 0) + rn = mpz_abs_add (r, a, b); + else + rn = mpz_abs_sub (r, a, b); + + r->_mp_size = a->_mp_size >= 0 ? rn : - rn; +} + +void +mpz_sub (mpz_t r, const mpz_t a, const mpz_t b) +{ + mp_size_t rn; + + if ( (a->_mp_size ^ b->_mp_size) >= 0) + rn = mpz_abs_sub (r, a, b); + else + rn = mpz_abs_add (r, a, b); + + r->_mp_size = a->_mp_size >= 0 ? rn : - rn; +} + + +/* MPZ multiplication */ +void +mpz_mul_si (mpz_t r, const mpz_t u, intMpz v) +{ + if (v < 0) + { + mpz_mul_ui (r, u, GMP_NEG_CAST (uIntMpz, v)); + mpz_neg (r, r); + } + else + mpz_mul_ui (r, u, (uIntMpz) v); +} + +void +mpz_mul_ui (mpz_t r, const mpz_t u, uIntMpz v) +{ + mp_size_t un, us; + mp_ptr tp; + mp_limb_t cy; + + us = u->_mp_size; + + if (us == 0 || v == 0) + { + r->_mp_size = 0; + return; + } + + un = GMP_ABS (us); + + tp = MPZ_REALLOC (r, un + 1); + cy = mpn_mul_1 (tp, u->_mp_d, un, v); + tp[un] = cy; + + un += (cy > 0); + r->_mp_size = (us < 0) ? - un : un; +} + +void +mpz_mul (mpz_t r, const mpz_t u, const mpz_t v) +{ + int sign; + mp_size_t un, vn, rn; + mpz_t t; + mp_ptr tp; + + un = u->_mp_size; + vn = v->_mp_size; + + if (un == 0 || vn == 0) + { + r->_mp_size = 0; + return; + } + + sign = (un ^ vn) < 0; + + un = GMP_ABS (un); + vn = GMP_ABS (vn); + + mpz_init2 (t, (un + vn) * GMP_LIMB_BITS); + + tp = t->_mp_d; + if (un >= vn) + mpn_mul (tp, u->_mp_d, un, v->_mp_d, vn); + else + mpn_mul (tp, v->_mp_d, vn, u->_mp_d, un); + + rn = un + vn; + rn -= tp[rn-1] == 0; + + t->_mp_size = sign ? - rn : rn; + mpz_swap (r, t); + mpz_clear (t); +} + +void +mpz_mul_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bits) +{ + mp_size_t un, rn; + mp_size_t limbs; + unsigned shift; + mp_ptr rp; + + un = GMP_ABS (u->_mp_size); + if (un == 0) + { + r->_mp_size = 0; + return; + } + + limbs = bits / GMP_LIMB_BITS; + shift = bits % GMP_LIMB_BITS; + + rn = un + limbs + (shift > 0); + rp = MPZ_REALLOC (r, rn); + if (shift > 0) + { + mp_limb_t cy = mpn_lshift (rp + limbs, u->_mp_d, un, shift); + rp[rn-1] = cy; + rn -= (cy == 0); + } + else + mpn_copyd (rp + limbs, u->_mp_d, un); + + mpn_zero (rp, limbs); + + r->_mp_size = (u->_mp_size < 0) ? - rn : rn; +} + +void +mpz_addmul_ui (mpz_t r, const mpz_t u, uIntMpz v) +{ + mpz_t t; + mpz_init (t); + mpz_mul_ui (t, u, v); + mpz_add (r, r, t); + mpz_clear (t); +} + +void +mpz_submul_ui (mpz_t r, const mpz_t u, uIntMpz v) +{ + mpz_t t; + mpz_init (t); + mpz_mul_ui (t, u, v); + mpz_sub (r, r, t); + mpz_clear (t); +} + +void +mpz_addmul (mpz_t r, const mpz_t u, const mpz_t v) +{ + mpz_t t; + mpz_init (t); + mpz_mul (t, u, v); + mpz_add (r, r, t); + mpz_clear (t); +} + +void +mpz_submul (mpz_t r, const mpz_t u, const mpz_t v) +{ + mpz_t t; + mpz_init (t); + mpz_mul (t, u, v); + mpz_sub (r, r, t); + mpz_clear (t); +} + + +/* MPZ division */ +enum mpz_div_round_mode { GMP_DIV_FLOOR, GMP_DIV_CEIL, GMP_DIV_TRUNC }; + +/* Allows q or r to be zero. Returns 1 iff remainder is non-zero. */ +static int +mpz_div_qr (mpz_t q, mpz_t r, + const mpz_t n, const mpz_t d, enum mpz_div_round_mode mode) +{ + mp_size_t ns, ds, nn, dn, qs; + ns = n->_mp_size; + ds = d->_mp_size; + + if (ds == 0) + gmp_die("mpz_div_qr: Divide by zero."); + + if (ns == 0) + { + if (q) + q->_mp_size = 0; + if (r) + r->_mp_size = 0; + return 0; + } + + nn = GMP_ABS (ns); + dn = GMP_ABS (ds); + + qs = ds ^ ns; + + if (nn < dn) + { + if (mode == GMP_DIV_CEIL && qs >= 0) + { + /* q = 1, r = n - d */ + if (r) + mpz_sub (r, n, d); + if (q) + mpz_set_ui (q, 1); + } + else if (mode == GMP_DIV_FLOOR && qs < 0) + { + /* q = -1, r = n + d */ + if (r) + mpz_add (r, n, d); + if (q) + mpz_set_si (q, -1); + } + else + { + /* q = 0, r = d */ + if (r) + mpz_set (r, n); + if (q) + q->_mp_size = 0; + } + return 1; + } + else + { + mp_ptr np, qp; + mp_size_t qn, rn; + mpz_t tq, tr; + + mpz_init_set (tr, n); + np = tr->_mp_d; + + qn = nn - dn + 1; + + if (q) + { + mpz_init2 (tq, qn * GMP_LIMB_BITS); + qp = tq->_mp_d; + } + else + qp = NULL; + + mpn_div_qr (qp, np, nn, d->_mp_d, dn); + + if (qp) + { + qn -= (qp[qn-1] == 0); + + tq->_mp_size = qs < 0 ? -qn : qn; + } + rn = mpn_normalized_size (np, dn); + tr->_mp_size = ns < 0 ? - rn : rn; + + if (mode == GMP_DIV_FLOOR && qs < 0 && rn != 0) + { + if (q) + mpz_sub_ui (tq, tq, 1); + if (r) + mpz_add (tr, tr, d); + } + else if (mode == GMP_DIV_CEIL && qs >= 0 && rn != 0) + { + if (q) + mpz_add_ui (tq, tq, 1); + if (r) + mpz_sub (tr, tr, d); + } + + if (q) + { + mpz_swap (tq, q); + mpz_clear (tq); + } + if (r) + mpz_swap (tr, r); + + mpz_clear (tr); + + return rn != 0; + } +} + +void +mpz_cdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, r, n, d, GMP_DIV_CEIL); +} + +void +mpz_fdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, r, n, d, GMP_DIV_FLOOR); +} + +void +mpz_tdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, r, n, d, GMP_DIV_TRUNC); +} + +void +mpz_cdiv_q (mpz_t q, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, NULL, n, d, GMP_DIV_CEIL); +} + +void +mpz_fdiv_q (mpz_t q, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, NULL, n, d, GMP_DIV_FLOOR); +} + +void +mpz_tdiv_q (mpz_t q, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (q, NULL, n, d, GMP_DIV_TRUNC); +} + +void +mpz_cdiv_r (mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (NULL, r, n, d, GMP_DIV_CEIL); +} + +void +mpz_fdiv_r (mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (NULL, r, n, d, GMP_DIV_FLOOR); +} + +void +mpz_tdiv_r (mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (NULL, r, n, d, GMP_DIV_TRUNC); +} + +void +mpz_mod (mpz_t r, const mpz_t n, const mpz_t d) +{ + mpz_div_qr (NULL, r, n, d, d->_mp_size >= 0 ? GMP_DIV_FLOOR : GMP_DIV_CEIL); +} + +static void +mpz_div_q_2exp (mpz_t q, const mpz_t u, mp_bitcnt_t bit_index, + enum mpz_div_round_mode mode) +{ + mp_size_t un, qn; + mp_size_t limb_cnt; + mp_ptr qp; + int adjust; + + un = u->_mp_size; + if (un == 0) + { + q->_mp_size = 0; + return; + } + limb_cnt = bit_index / GMP_LIMB_BITS; + qn = GMP_ABS (un) - limb_cnt; + bit_index %= GMP_LIMB_BITS; + + if (mode == ((un > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* un != 0 here. */ + /* Note: Below, the final indexing at limb_cnt is valid because at + that point we have qn > 0. */ + adjust = (qn <= 0 + || !mpn_zero_p (u->_mp_d, limb_cnt) + || (u->_mp_d[limb_cnt] + & (((mp_limb_t) 1 << bit_index) - 1))); + else + adjust = 0; + + if (qn <= 0) + qn = 0; + else + { + qp = MPZ_REALLOC (q, qn); + + if (bit_index != 0) + { + mpn_rshift (qp, u->_mp_d + limb_cnt, qn, bit_index); + qn -= qp[qn - 1] == 0; + } + else + { + mpn_copyi (qp, u->_mp_d + limb_cnt, qn); + } + } + + q->_mp_size = qn; + + if (adjust) + mpz_add_ui (q, q, 1); + if (un < 0) + mpz_neg (q, q); +} + +static void +mpz_div_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bit_index, + enum mpz_div_round_mode mode) +{ + mp_size_t us, un, rn; + mp_ptr rp; + mp_limb_t mask; + + us = u->_mp_size; + if (us == 0 || bit_index == 0) + { + r->_mp_size = 0; + return; + } + rn = (bit_index + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS; + assert (rn > 0); + + rp = MPZ_REALLOC (r, rn); + un = GMP_ABS (us); + + mask = GMP_LIMB_MAX >> (rn * GMP_LIMB_BITS - bit_index); + + if (rn > un) + { + /* Quotient (with truncation) is zero, and remainder is + non-zero */ + if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */ + { + /* Have to negate and sign extend. */ + mp_size_t i; + + gmp_assert_nocarry (! mpn_neg (rp, u->_mp_d, un)); + for (i = un; i < rn - 1; i++) + rp[i] = GMP_LIMB_MAX; + + rp[rn-1] = mask; + us = -us; + } + else + { + /* Just copy */ + if (r != u) + mpn_copyi (rp, u->_mp_d, un); + + rn = un; + } + } + else + { + if (r != u) + mpn_copyi (rp, u->_mp_d, rn - 1); + + rp[rn-1] = u->_mp_d[rn-1] & mask; + + if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */ + { + /* If r != 0, compute 2^{bit_count} - r. */ + mpn_neg (rp, rp, rn); + + rp[rn-1] &= mask; + + /* us is not used for anything else, so we can modify it + here to indicate flipped sign. */ + us = -us; + } + } + rn = mpn_normalized_size (rp, rn); + r->_mp_size = us < 0 ? -rn : rn; +} + +void +mpz_cdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_q_2exp (r, u, cnt, GMP_DIV_CEIL); +} + +void +mpz_fdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_q_2exp (r, u, cnt, GMP_DIV_FLOOR); +} + +void +mpz_tdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_q_2exp (r, u, cnt, GMP_DIV_TRUNC); +} + +void +mpz_cdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_r_2exp (r, u, cnt, GMP_DIV_CEIL); +} + +void +mpz_fdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_r_2exp (r, u, cnt, GMP_DIV_FLOOR); +} + +void +mpz_tdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt) +{ + mpz_div_r_2exp (r, u, cnt, GMP_DIV_TRUNC); +} + +void +mpz_divexact (mpz_t q, const mpz_t n, const mpz_t d) +{ + gmp_assert_nocarry (mpz_div_qr (q, NULL, n, d, GMP_DIV_TRUNC)); +} + +int +mpz_divisible_p (const mpz_t n, const mpz_t d) +{ + return mpz_div_qr (NULL, NULL, n, d, GMP_DIV_TRUNC) == 0; +} + +int +mpz_congruent_p (const mpz_t a, const mpz_t b, const mpz_t m) +{ + mpz_t t; + int res; + + /* a == b (mod 0) iff a == b */ + if (mpz_sgn (m) == 0) + return (mpz_cmp (a, b) == 0); + + mpz_init (t); + mpz_sub (t, a, b); + res = mpz_divisible_p (t, m); + mpz_clear (t); + + return res; +} + +static uIntMpz +mpz_div_qr_ui (mpz_t q, mpz_t r, + const mpz_t n, uIntMpz d, enum mpz_div_round_mode mode) +{ + mp_size_t ns, qn; + mp_ptr qp; + mp_limb_t rl; + mp_size_t rs; + + ns = n->_mp_size; + if (ns == 0) + { + if (q) + q->_mp_size = 0; + if (r) + r->_mp_size = 0; + return 0; + } + + qn = GMP_ABS (ns); + if (q) + qp = MPZ_REALLOC (q, qn); + else + qp = NULL; + + rl = mpn_div_qr_1 (qp, n->_mp_d, qn, d); + assert (rl < d); + + rs = rl > 0; + rs = (ns < 0) ? -rs : rs; + + if (rl > 0 && ( (mode == GMP_DIV_FLOOR && ns < 0) + || (mode == GMP_DIV_CEIL && ns >= 0))) + { + if (q) + gmp_assert_nocarry (mpn_add_1 (qp, qp, qn, 1)); + rl = d - rl; + rs = -rs; + } + + if (r) + { + MPZ_REALLOC (r, 1)[0] = rl; + r->_mp_size = rs; + } + if (q) + { + qn -= (qp[qn-1] == 0); + assert (qn == 0 || qp[qn-1] > 0); + + q->_mp_size = (ns < 0) ? - qn : qn; + } + + return rl; +} + +uIntMpz +mpz_cdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, r, n, d, GMP_DIV_CEIL); +} + +uIntMpz +mpz_fdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, r, n, d, GMP_DIV_FLOOR); +} + +uIntMpz +mpz_tdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, r, n, d, GMP_DIV_TRUNC); +} + +uIntMpz +mpz_cdiv_q_ui (mpz_t q, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_CEIL); +} + +uIntMpz +mpz_fdiv_q_ui (mpz_t q, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_FLOOR); +} + +uIntMpz +mpz_tdiv_q_ui (mpz_t q, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_TRUNC); +} + +uIntMpz +mpz_cdiv_r_ui (mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_CEIL); +} +uIntMpz +mpz_fdiv_r_ui (mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_FLOOR); +} +uIntMpz +mpz_tdiv_r_ui (mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_TRUNC); +} + +uIntMpz +mpz_cdiv_ui (const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_CEIL); +} + +uIntMpz +mpz_fdiv_ui (const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_FLOOR); +} + +uIntMpz +mpz_tdiv_ui (const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_TRUNC); +} + +uIntMpz +mpz_mod_ui (mpz_t r, const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_FLOOR); +} + +void +mpz_divexact_ui (mpz_t q, const mpz_t n, uIntMpz d) +{ + gmp_assert_nocarry (mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_TRUNC)); +} + +int +mpz_divisible_ui_p (const mpz_t n, uIntMpz d) +{ + return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_TRUNC) == 0; +} + + +/* GCD */ +static mp_limb_t +mpn_gcd_11 (mp_limb_t u, mp_limb_t v) +{ + unsigned shift; + + assert ( (u | v) > 0); + + if (u == 0) + return v; + else if (v == 0) + return u; + + gmp_ctz (shift, u | v); + + u >>= shift; + v >>= shift; + + if ( (u & 1) == 0) + MP_LIMB_T_SWAP (u, v); + + while ( (v & 1) == 0) + v >>= 1; + + while (u != v) + { + if (u > v) + { + u -= v; + do + u >>= 1; + while ( (u & 1) == 0); + } + else + { + v -= u; + do + v >>= 1; + while ( (v & 1) == 0); + } + } + return u << shift; +} + +uIntMpz +mpz_gcd_ui (mpz_t g, const mpz_t u, uIntMpz v) +{ + mp_size_t un; + + if (v == 0) + { + if (g) + mpz_abs (g, u); + } + else + { + un = GMP_ABS (u->_mp_size); + if (un != 0) + v = mpn_gcd_11 (mpn_div_qr_1 (NULL, u->_mp_d, un, v), v); + + if (g) + mpz_set_ui (g, v); + } + + return v; +} + +static mp_bitcnt_t +mpz_make_odd (mpz_t r) +{ + mp_bitcnt_t shift; + + assert (r->_mp_size > 0); + /* Count trailing zeros, equivalent to mpn_scan1, because we know that there is a 1 */ + shift = mpn_common_scan (r->_mp_d[0], 0, r->_mp_d, 0, 0); + mpz_tdiv_q_2exp (r, r, shift); + + return shift; +} + +void +mpz_gcd (mpz_t g, const mpz_t u, const mpz_t v) +{ + mpz_t tu, tv; + mp_bitcnt_t uz, vz, gz; + + if (u->_mp_size == 0) + { + mpz_abs (g, v); + return; + } + if (v->_mp_size == 0) + { + mpz_abs (g, u); + return; + } + + mpz_init (tu); + mpz_init (tv); + + mpz_abs (tu, u); + uz = mpz_make_odd (tu); + mpz_abs (tv, v); + vz = mpz_make_odd (tv); + gz = GMP_MIN (uz, vz); + + if (tu->_mp_size < tv->_mp_size) + mpz_swap (tu, tv); + + mpz_tdiv_r (tu, tu, tv); + if (tu->_mp_size == 0) + { + mpz_swap (g, tv); + } + else + for (;;) + { + int c; + + mpz_make_odd (tu); + c = mpz_cmp (tu, tv); + if (c == 0) + { + mpz_swap (g, tu); + break; + } + if (c < 0) + mpz_swap (tu, tv); + + if (tv->_mp_size == 1) + { + mp_limb_t vl = tv->_mp_d[0]; + mp_limb_t ul = mpz_tdiv_ui (tu, vl); + mpz_set_ui (g, mpn_gcd_11 (ul, vl)); + break; + } + mpz_sub (tu, tu, tv); + } + mpz_clear (tu); + mpz_clear (tv); + mpz_mul_2exp (g, g, gz); +} + +void +mpz_gcdext (mpz_t g, mpz_t s, mpz_t t, const mpz_t u, const mpz_t v) +{ + mpz_t tu, tv, s0, s1, t0, t1; + mp_bitcnt_t uz, vz, gz; + mp_bitcnt_t power; + + if (u->_mp_size == 0) + { + /* g = 0 u + sgn(v) v */ + intMpz sign = mpz_sgn (v); + mpz_abs (g, v); + if (s) + mpz_set_ui (s, 0); + if (t) + mpz_set_si (t, sign); + return; + } + + if (v->_mp_size == 0) + { + /* g = sgn(u) u + 0 v */ + intMpz sign = mpz_sgn (u); + mpz_abs (g, u); + if (s) + mpz_set_si (s, sign); + if (t) + mpz_set_ui (t, 0); + return; + } + + mpz_init (tu); + mpz_init (tv); + mpz_init (s0); + mpz_init (s1); + mpz_init (t0); + mpz_init (t1); + + mpz_abs (tu, u); + uz = mpz_make_odd (tu); + mpz_abs (tv, v); + vz = mpz_make_odd (tv); + gz = GMP_MIN (uz, vz); + + uz -= gz; + vz -= gz; + + /* Cofactors corresponding to odd gcd. gz handled later. */ + if (tu->_mp_size < tv->_mp_size) + { + mpz_swap (tu, tv); + MPZ_SRCPTR_SWAP (u, v); + MPZ_PTR_SWAP (s, t); + MP_BITCNT_T_SWAP (uz, vz); + } + + /* Maintain + * + * u = t0 tu + t1 tv + * v = s0 tu + s1 tv + * + * where u and v denote the inputs with common factors of two + * eliminated, and det (s0, t0; s1, t1) = 2^p. Then + * + * 2^p tu = s1 u - t1 v + * 2^p tv = -s0 u + t0 v + */ + + /* After initial division, tu = q tv + tu', we have + * + * u = 2^uz (tu' + q tv) + * v = 2^vz tv + * + * or + * + * t0 = 2^uz, t1 = 2^uz q + * s0 = 0, s1 = 2^vz + */ + + mpz_setbit (t0, uz); + mpz_tdiv_qr (t1, tu, tu, tv); + mpz_mul_2exp (t1, t1, uz); + + mpz_setbit (s1, vz); + power = uz + vz; + + if (tu->_mp_size > 0) + { + mp_bitcnt_t shift; + shift = mpz_make_odd (tu); + mpz_mul_2exp (t0, t0, shift); + mpz_mul_2exp (s0, s0, shift); + power += shift; + + for (;;) + { + int c; + c = mpz_cmp (tu, tv); + if (c == 0) + break; + + if (c < 0) + { + /* tv = tv' + tu + * + * u = t0 tu + t1 (tv' + tu) = (t0 + t1) tu + t1 tv' + * v = s0 tu + s1 (tv' + tu) = (s0 + s1) tu + s1 tv' */ + + mpz_sub (tv, tv, tu); + mpz_add (t0, t0, t1); + mpz_add (s0, s0, s1); + + shift = mpz_make_odd (tv); + mpz_mul_2exp (t1, t1, shift); + mpz_mul_2exp (s1, s1, shift); + } + else + { + mpz_sub (tu, tu, tv); + mpz_add (t1, t0, t1); + mpz_add (s1, s0, s1); + + shift = mpz_make_odd (tu); + mpz_mul_2exp (t0, t0, shift); + mpz_mul_2exp (s0, s0, shift); + } + power += shift; + } + } + + /* Now tv = odd part of gcd, and -s0 and t0 are corresponding + cofactors. */ + + mpz_mul_2exp (tv, tv, gz); + mpz_neg (s0, s0); + + /* 2^p g = s0 u + t0 v. Eliminate one factor of two at a time. To + adjust cofactors, we need u / g and v / g */ + + mpz_divexact (s1, v, tv); + mpz_abs (s1, s1); + mpz_divexact (t1, u, tv); + mpz_abs (t1, t1); + + while (power-- > 0) + { + /* s0 u + t0 v = (s0 - v/g) u - (t0 + u/g) v */ + if (mpz_odd_p (s0) || mpz_odd_p (t0)) + { + mpz_sub (s0, s0, s1); + mpz_add (t0, t0, t1); + } + mpz_divexact_ui (s0, s0, 2); + mpz_divexact_ui (t0, t0, 2); + } + + /* Arrange so that |s| < |u| / 2g */ + mpz_add (s1, s0, s1); + if (mpz_cmpabs (s0, s1) > 0) + { + mpz_swap (s0, s1); + mpz_sub (t0, t0, t1); + } + if (u->_mp_size < 0) + mpz_neg (s0, s0); + if (v->_mp_size < 0) + mpz_neg (t0, t0); + + mpz_swap (g, tv); + if (s) + mpz_swap (s, s0); + if (t) + mpz_swap (t, t0); + + mpz_clear (tu); + mpz_clear (tv); + mpz_clear (s0); + mpz_clear (s1); + mpz_clear (t0); + mpz_clear (t1); +} + +void +mpz_lcm (mpz_t r, const mpz_t u, const mpz_t v) +{ + mpz_t g; + + if (u->_mp_size == 0 || v->_mp_size == 0) + { + r->_mp_size = 0; + return; + } + + mpz_init (g); + + mpz_gcd (g, u, v); + mpz_divexact (g, u, g); + mpz_mul (r, g, v); + + mpz_clear (g); + mpz_abs (r, r); +} + +void +mpz_lcm_ui (mpz_t r, const mpz_t u, uIntMpz v) +{ + if (v == 0 || u->_mp_size == 0) + { + r->_mp_size = 0; + return; + } + + v /= mpz_gcd_ui (NULL, u, v); + mpz_mul_ui (r, u, v); + + mpz_abs (r, r); +} + +int +mpz_invert (mpz_t r, const mpz_t u, const mpz_t m) +{ + mpz_t g, tr; + int invertible; + + if (u->_mp_size == 0 || mpz_cmpabs_ui (m, 1) <= 0) + return 0; + + mpz_init (g); + mpz_init (tr); + + mpz_gcdext (g, tr, NULL, u, m); + invertible = (mpz_cmp_ui (g, 1) == 0); + + if (invertible) + { + if (tr->_mp_size < 0) + { + if (m->_mp_size >= 0) + mpz_add (tr, tr, m); + else + mpz_sub (tr, tr, m); + } + mpz_swap (r, tr); + } + + mpz_clear (g); + mpz_clear (tr); + return invertible; +} + + +/* Higher level operations (sqrt, pow and root) */ + +void +mpz_pow_ui (mpz_t r, const mpz_t b, uIntMpz e) +{ + uIntMpz bit; + mpz_t tr; + mpz_init_set_ui (tr, 1); + + bit = GMP_ULONG_HIGHBIT; + do + { + mpz_mul (tr, tr, tr); + if (e & bit) + mpz_mul (tr, tr, b); + bit >>= 1; + } + while (bit > 0); + + mpz_swap (r, tr); + mpz_clear (tr); +} + +void +mpz_ui_pow_ui (mpz_t r, uIntMpz blimb, uIntMpz e) +{ + mpz_t b; + mpz_pow_ui (r, mpz_roinit_n (b, &blimb, 1), e); +} + +void +mpz_powm (mpz_t r, const mpz_t b, const mpz_t e, const mpz_t m) +{ + mpz_t tr; + mpz_t base; + mp_size_t en, mn; + mp_srcptr mp; + struct gmp_div_inverse minv; + unsigned shift; + mp_ptr tp = NULL; + + en = GMP_ABS (e->_mp_size); + mn = GMP_ABS (m->_mp_size); + if (mn == 0) + gmp_die ("mpz_powm: Zero modulo."); + + if (en == 0) + { + mpz_set_ui (r, 1); + return; + } + + mp = m->_mp_d; + mpn_div_qr_invert (&minv, mp, mn); + shift = minv.shift; + + if (shift > 0) + { + /* To avoid shifts, we do all our reductions, except the final + one, using a *normalized* m. */ + minv.shift = 0; + + tp = gmp_xalloc_limbs (mn); + gmp_assert_nocarry (mpn_lshift (tp, mp, mn, shift)); + mp = tp; + } + + mpz_init (base); + + if (e->_mp_size < 0) + { + if (!mpz_invert (base, b, m)) + gmp_die ("mpz_powm: Negative exponent and non-invertible base."); + } + else + { + mp_size_t bn; + mpz_abs (base, b); + + bn = base->_mp_size; + if (bn >= mn) + { + mpn_div_qr_preinv (NULL, base->_mp_d, base->_mp_size, mp, mn, &minv); + bn = mn; + } + + /* We have reduced the absolute value. Now take care of the + sign. Note that we get zero represented non-canonically as + m. */ + if (b->_mp_size < 0) + { + mp_ptr bp = MPZ_REALLOC (base, mn); + gmp_assert_nocarry (mpn_sub (bp, mp, mn, bp, bn)); + bn = mn; + } + base->_mp_size = mpn_normalized_size (base->_mp_d, bn); + } + mpz_init_set_ui (tr, 1); + + while (--en >= 0) + { + mp_limb_t w = e->_mp_d[en]; + mp_limb_t bit; + + bit = GMP_LIMB_HIGHBIT; + do + { + mpz_mul (tr, tr, tr); + if (w & bit) + mpz_mul (tr, tr, base); + if (tr->_mp_size > mn) + { + mpn_div_qr_preinv (NULL, tr->_mp_d, tr->_mp_size, mp, mn, &minv); + tr->_mp_size = mpn_normalized_size (tr->_mp_d, mn); + } + bit >>= 1; + } + while (bit > 0); + } + + /* Final reduction */ + if (tr->_mp_size >= mn) + { + minv.shift = shift; + mpn_div_qr_preinv (NULL, tr->_mp_d, tr->_mp_size, mp, mn, &minv); + tr->_mp_size = mpn_normalized_size (tr->_mp_d, mn); + } + if (tp) + gmp_free (tp); + + mpz_swap (r, tr); + mpz_clear (tr); + mpz_clear (base); +} + +void +mpz_powm_ui (mpz_t r, const mpz_t b, uIntMpz elimb, const mpz_t m) +{ + mpz_t e; + mpz_powm (r, b, mpz_roinit_n (e, &elimb, 1), m); +} + +/* x=trunc(y^(1/z)), r=y-x^z */ +void +mpz_rootrem (mpz_t x, mpz_t r, const mpz_t y, uIntMpz z) +{ + int sgn; + mpz_t t, u; + + sgn = y->_mp_size < 0; + if ((~z & sgn) != 0) + gmp_die ("mpz_rootrem: Negative argument, with even root."); + if (z == 0) + gmp_die ("mpz_rootrem: Zeroth root."); + + if (mpz_cmpabs_ui (y, 1) <= 0) { + if (x) + mpz_set (x, y); + if (r) + r->_mp_size = 0; + return; + } + + mpz_init (u); + mpz_init (t); + mpz_setbit (t, mpz_sizeinbase (y, 2) / z + 1); + + if (z == 2) /* simplify sqrt loop: z-1 == 1 */ + do { + mpz_swap (u, t); /* u = x */ + mpz_tdiv_q (t, y, u); /* t = y/x */ + mpz_add (t, t, u); /* t = y/x + x */ + mpz_tdiv_q_2exp (t, t, 1); /* x'= (y/x + x)/2 */ + } while (mpz_cmpabs (t, u) < 0); /* |x'| < |x| */ + else /* z != 2 */ { + mpz_t v; + + mpz_init (v); + if (sgn) + mpz_neg (t, t); + + do { + mpz_swap (u, t); /* u = x */ + mpz_pow_ui (t, u, z - 1); /* t = x^(z-1) */ + mpz_tdiv_q (t, y, t); /* t = y/x^(z-1) */ + mpz_mul_ui (v, u, z - 1); /* v = x*(z-1) */ + mpz_add (t, t, v); /* t = y/x^(z-1) + x*(z-1) */ + mpz_tdiv_q_ui (t, t, z); /* x'=(y/x^(z-1) + x*(z-1))/z */ + } while (mpz_cmpabs (t, u) < 0); /* |x'| < |x| */ + + mpz_clear (v); + } + + if (r) { + mpz_pow_ui (t, u, z); + mpz_sub (r, y, t); + } + if (x) + mpz_swap (x, u); + mpz_clear (u); + mpz_clear (t); +} + +int +mpz_root (mpz_t x, const mpz_t y, uIntMpz z) +{ + int res; + mpz_t r; + + mpz_init (r); + mpz_rootrem (x, r, y, z); + res = r->_mp_size == 0; + mpz_clear (r); + + return res; +} + +/* Compute s = floor(sqrt(u)) and r = u - s^2. Allows r == NULL */ +void +mpz_sqrtrem (mpz_t s, mpz_t r, const mpz_t u) +{ + mpz_rootrem (s, r, u, 2); +} + +void +mpz_sqrt (mpz_t s, const mpz_t u) +{ + mpz_rootrem (s, NULL, u, 2); +} + +int +mpz_perfect_square_p (const mpz_t u) +{ + if (u->_mp_size <= 0) + return (u->_mp_size == 0); + else + return mpz_root (NULL, u, 2); +} + +int +mpn_perfect_square_p (mp_srcptr p, mp_size_t n) +{ + mpz_t t; + + assert (n > 0); + assert (p [n-1] != 0); + return mpz_root (NULL, mpz_roinit_n (t, p, n), 2); +} + +mp_size_t +mpn_sqrtrem (mp_ptr sp, mp_ptr rp, mp_srcptr p, mp_size_t n) +{ + mpz_t s, r, u; + mp_size_t res; + + assert (n > 0); + assert (p [n-1] != 0); + + mpz_init (r); + mpz_init (s); + mpz_rootrem (s, r, mpz_roinit_n (u, p, n), 2); + + assert (s->_mp_size == (n+1)/2); + mpn_copyd (sp, s->_mp_d, s->_mp_size); + mpz_clear (s); + res = r->_mp_size; + if (rp) + mpn_copyd (rp, r->_mp_d, res); + mpz_clear (r); + return res; +} + +/* Combinatorics */ + +void +mpz_fac_ui (mpz_t x, uIntMpz n) +{ + mpz_set_ui (x, n + (n == 0)); + while (n > 2) + mpz_mul_ui (x, x, --n); +} + +void +mpz_bin_uiui (mpz_t r, uIntMpz n, uIntMpz k) +{ + mpz_t t; + + mpz_set_ui (r, k <= n); + + if (k > (n >> 1)) + k = (k <= n) ? n - k : 0; + + mpz_init (t); + mpz_fac_ui (t, k); + + for (; k > 0; k--) + mpz_mul_ui (r, r, n--); + + mpz_divexact (r, r, t); + mpz_clear (t); +} + + +/* Primality testing */ +static int +gmp_millerrabin (const mpz_t n, const mpz_t nm1, mpz_t y, + const mpz_t q, mp_bitcnt_t k) +{ + assert (k > 0); + + /* Caller must initialize y to the base. */ + mpz_powm (y, y, q, n); + + if (mpz_cmp_ui (y, 1) == 0 || mpz_cmp (y, nm1) == 0) + return 1; + + while (--k > 0) + { + mpz_powm_ui (y, y, 2, n); + if (mpz_cmp (y, nm1) == 0) + return 1; + /* y == 1 means that the previous y was a non-trivial square root + of 1 (mod n). y == 0 means that n is a power of the base. + In either case, n is not prime. */ + if (mpz_cmp_ui (y, 1) <= 0) + return 0; + } + return 0; +} + +/* This product is 0xc0cfd797, and fits in 32 bits. */ +#define GMP_PRIME_PRODUCT \ + (3UL*5UL*7UL*11UL*13UL*17UL*19UL*23UL*29UL) + +/* Bit (p+1)/2 is set, for each odd prime <= 61 */ +#define GMP_PRIME_MASK 0xc96996dcUL + +int +mpz_probab_prime_p (const mpz_t n, int reps) +{ + mpz_t nm1; + mpz_t q; + mpz_t y; + mp_bitcnt_t k; + int is_prime; + int j; + + /* Note that we use the absolute value of n only, for compatibility + with the real GMP. */ + if (mpz_even_p (n)) + return (mpz_cmpabs_ui (n, 2) == 0) ? 2 : 0; + + /* Above test excludes n == 0 */ + assert (n->_mp_size != 0); + + if (mpz_cmpabs_ui (n, 64) < 0) + return (GMP_PRIME_MASK >> (n->_mp_d[0] >> 1)) & 2; + + if (mpz_gcd_ui (NULL, n, GMP_PRIME_PRODUCT) != 1) + return 0; + + /* All prime factors are >= 31. */ + if (mpz_cmpabs_ui (n, 31*31) < 0) + return 2; + + /* Use Miller-Rabin, with a deterministic sequence of bases, a[j] = + j^2 + j + 41 using Euler's polynomial. We potentially stop early, + if a[j] >= n - 1. Since n >= 31*31, this can happen only if reps > + 30 (a[30] == 971 > 31*31 == 961). */ + + mpz_init (nm1); + mpz_init (q); + mpz_init (y); + + /* Find q and k, where q is odd and n = 1 + 2**k * q. */ + nm1->_mp_size = mpz_abs_sub_ui (nm1, n, 1); + k = mpz_scan1 (nm1, 0); + mpz_tdiv_q_2exp (q, nm1, k); + + for (j = 0, is_prime = 1; is_prime & (j < reps); j++) + { + mpz_set_ui (y, (uIntMpz) j*j+j+41); + if (mpz_cmp (y, nm1) >= 0) + { + /* Don't try any further bases. This "early" break does not affect + the result for any reasonable reps value (<=5000 was tested) */ + assert (j >= 30); + break; + } + is_prime = gmp_millerrabin (n, nm1, y, q, k); + } + mpz_clear (nm1); + mpz_clear (q); + mpz_clear (y); + + return is_prime; +} + + +/* Logical operations and bit manipulation. */ + +/* Numbers are treated as if represented in two's complement (and + infinitely sign extended). For a negative values we get the two's + complement from -x = ~x + 1, where ~ is bitwise complement. + Negation transforms + + xxxx10...0 + + into + + yyyy10...0 + + where yyyy is the bitwise complement of xxxx. So least significant + bits, up to and including the first one bit, are unchanged, and + the more significant bits are all complemented. + + To change a bit from zero to one in a negative number, subtract the + corresponding power of two from the absolute value. This can never + underflow. To change a bit from one to zero, add the corresponding + power of two, and this might overflow. E.g., if x = -001111, the + two's complement is 110001. Clearing the least significant bit, we + get two's complement 110000, and -010000. */ + +int +mpz_tstbit (const mpz_t d, mp_bitcnt_t bit_index) +{ + mp_size_t limb_index; + unsigned shift; + mp_size_t ds; + mp_size_t dn; + mp_limb_t w; + int bit; + + ds = d->_mp_size; + dn = GMP_ABS (ds); + limb_index = bit_index / GMP_LIMB_BITS; + if (limb_index >= dn) + return ds < 0; + + shift = bit_index % GMP_LIMB_BITS; + w = d->_mp_d[limb_index]; + bit = (w >> shift) & 1; + + if (ds < 0) + { + /* d < 0. Check if any of the bits below is set: If so, our bit + must be complemented. */ + if (shift > 0 && (w << (GMP_LIMB_BITS - shift)) > 0) + return bit ^ 1; + while (--limb_index >= 0) + if (d->_mp_d[limb_index] > 0) + return bit ^ 1; + } + return bit; +} + +static void +mpz_abs_add_bit (mpz_t d, mp_bitcnt_t bit_index) +{ + mp_size_t dn, limb_index; + mp_limb_t bit; + mp_ptr dp; + + dn = GMP_ABS (d->_mp_size); + + limb_index = bit_index / GMP_LIMB_BITS; + bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS); + + if (limb_index >= dn) + { + mp_size_t i; + /* The bit should be set outside of the end of the number. + We have to increase the size of the number. */ + dp = MPZ_REALLOC (d, limb_index + 1); + + dp[limb_index] = bit; + for (i = dn; i < limb_index; i++) + dp[i] = 0; + dn = limb_index + 1; + } + else + { + mp_limb_t cy; + + dp = d->_mp_d; + + cy = mpn_add_1 (dp + limb_index, dp + limb_index, dn - limb_index, bit); + if (cy > 0) + { + dp = MPZ_REALLOC (d, dn + 1); + dp[dn++] = cy; + } + } + + d->_mp_size = (d->_mp_size < 0) ? - dn : dn; +} + +static void +mpz_abs_sub_bit (mpz_t d, mp_bitcnt_t bit_index) +{ + mp_size_t dn, limb_index; + mp_ptr dp; + mp_limb_t bit; + + dn = GMP_ABS (d->_mp_size); + dp = d->_mp_d; + + limb_index = bit_index / GMP_LIMB_BITS; + bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS); + + assert (limb_index < dn); + + gmp_assert_nocarry (mpn_sub_1 (dp + limb_index, dp + limb_index, + dn - limb_index, bit)); + dn = mpn_normalized_size (dp, dn); + d->_mp_size = (d->_mp_size < 0) ? - dn : dn; +} + +void +mpz_setbit (mpz_t d, mp_bitcnt_t bit_index) +{ + if (!mpz_tstbit (d, bit_index)) + { + if (d->_mp_size >= 0) + mpz_abs_add_bit (d, bit_index); + else + mpz_abs_sub_bit (d, bit_index); + } +} + +void +mpz_clrbit (mpz_t d, mp_bitcnt_t bit_index) +{ + if (mpz_tstbit (d, bit_index)) + { + if (d->_mp_size >= 0) + mpz_abs_sub_bit (d, bit_index); + else + mpz_abs_add_bit (d, bit_index); + } +} + +void +mpz_combit (mpz_t d, mp_bitcnt_t bit_index) +{ + if (mpz_tstbit (d, bit_index) ^ (d->_mp_size < 0)) + mpz_abs_sub_bit (d, bit_index); + else + mpz_abs_add_bit (d, bit_index); +} + +void +mpz_com (mpz_t r, const mpz_t u) +{ + mpz_neg (r, u); + mpz_sub_ui (r, r, 1); +} + +void +mpz_and (mpz_t r, const mpz_t u, const mpz_t v) +{ + mp_size_t un, vn, rn, i; + mp_ptr up, vp, rp; + + mp_limb_t ux, vx, rx; + mp_limb_t uc, vc, rc; + mp_limb_t ul, vl, rl; + + un = GMP_ABS (u->_mp_size); + vn = GMP_ABS (v->_mp_size); + if (un < vn) + { + MPZ_SRCPTR_SWAP (u, v); + MP_SIZE_T_SWAP (un, vn); + } + if (vn == 0) + { + r->_mp_size = 0; + return; + } + + uc = u->_mp_size < 0; + vc = v->_mp_size < 0; + rc = uc & vc; + + ux = -uc; + vx = -vc; + rx = -rc; + + /* If the smaller input is positive, higher limbs don't matter. */ + rn = vx ? un : vn; + + rp = MPZ_REALLOC (r, rn + (mp_size_t) rc); + + up = u->_mp_d; + vp = v->_mp_d; + + i = 0; + do + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + vl = (vp[i] ^ vx) + vc; + vc = vl < vc; + + rl = ( (ul & vl) ^ rx) + rc; + rc = rl < rc; + rp[i] = rl; + } + while (++i < vn); + assert (vc == 0); + + for (; i < rn; i++) + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + rl = ( (ul & vx) ^ rx) + rc; + rc = rl < rc; + rp[i] = rl; + } + if (rc) + rp[rn++] = rc; + else + rn = mpn_normalized_size (rp, rn); + + r->_mp_size = rx ? -rn : rn; +} + +void +mpz_ior (mpz_t r, const mpz_t u, const mpz_t v) +{ + mp_size_t un, vn, rn, i; + mp_ptr up, vp, rp; + + mp_limb_t ux, vx, rx; + mp_limb_t uc, vc, rc; + mp_limb_t ul, vl, rl; + + un = GMP_ABS (u->_mp_size); + vn = GMP_ABS (v->_mp_size); + if (un < vn) + { + MPZ_SRCPTR_SWAP (u, v); + MP_SIZE_T_SWAP (un, vn); + } + if (vn == 0) + { + mpz_set (r, u); + return; + } + + uc = u->_mp_size < 0; + vc = v->_mp_size < 0; + rc = uc | vc; + + ux = -uc; + vx = -vc; + rx = -rc; + + /* If the smaller input is negative, by sign extension higher limbs + don't matter. */ + rn = vx ? vn : un; + + rp = MPZ_REALLOC (r, rn + (mp_size_t) rc); + + up = u->_mp_d; + vp = v->_mp_d; + + i = 0; + do + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + vl = (vp[i] ^ vx) + vc; + vc = vl < vc; + + rl = ( (ul | vl) ^ rx) + rc; + rc = rl < rc; + rp[i] = rl; + } + while (++i < vn); + assert (vc == 0); + + for (; i < rn; i++) + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + rl = ( (ul | vx) ^ rx) + rc; + rc = rl < rc; + rp[i] = rl; + } + if (rc) + rp[rn++] = rc; + else + rn = mpn_normalized_size (rp, rn); + + r->_mp_size = rx ? -rn : rn; +} + +void +mpz_xor (mpz_t r, const mpz_t u, const mpz_t v) +{ + mp_size_t un, vn, i; + mp_ptr up, vp, rp; + + mp_limb_t ux, vx, rx; + mp_limb_t uc, vc, rc; + mp_limb_t ul, vl, rl; + + un = GMP_ABS (u->_mp_size); + vn = GMP_ABS (v->_mp_size); + if (un < vn) + { + MPZ_SRCPTR_SWAP (u, v); + MP_SIZE_T_SWAP (un, vn); + } + if (vn == 0) + { + mpz_set (r, u); + return; + } + + uc = u->_mp_size < 0; + vc = v->_mp_size < 0; + rc = uc ^ vc; + + ux = -uc; + vx = -vc; + rx = -rc; + + rp = MPZ_REALLOC (r, un + (mp_size_t) rc); + + up = u->_mp_d; + vp = v->_mp_d; + + i = 0; + do + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + vl = (vp[i] ^ vx) + vc; + vc = vl < vc; + + rl = (ul ^ vl ^ rx) + rc; + rc = rl < rc; + rp[i] = rl; + } + while (++i < vn); + assert (vc == 0); + + for (; i < un; i++) + { + ul = (up[i] ^ ux) + uc; + uc = ul < uc; + + rl = (ul ^ ux) + rc; + rc = rl < rc; + rp[i] = rl; + } + if (rc) + rp[un++] = rc; + else + un = mpn_normalized_size (rp, un); + + r->_mp_size = rx ? -un : un; +} + +static unsigned +gmp_popcount_limb (mp_limb_t x) +{ + unsigned c; + + /* Do 16 bits at a time, to avoid limb-sized constants. */ + for (c = 0; x > 0; x >>= 16) + { + unsigned w = ((x >> 1) & 0x5555) + (x & 0x5555); + w = ((w >> 2) & 0x3333) + (w & 0x3333); + w = ((w >> 4) & 0x0f0f) + (w & 0x0f0f); + w = (w >> 8) + (w & 0x00ff); + c += w; + } + return c; +} + +mp_bitcnt_t +mpn_popcount (mp_srcptr p, mp_size_t n) +{ + mp_size_t i; + mp_bitcnt_t c; + + for (c = 0, i = 0; i < n; i++) + c += gmp_popcount_limb (p[i]); + + return c; +} + +mp_bitcnt_t +mpz_popcount (const mpz_t u) +{ + mp_size_t un; + + un = u->_mp_size; + + if (un < 0) + return ~(mp_bitcnt_t) 0; + + return mpn_popcount (u->_mp_d, un); +} + +mp_bitcnt_t +mpz_hamdist (const mpz_t u, const mpz_t v) +{ + mp_size_t un, vn, i; + mp_limb_t uc, vc, ul, vl, comp; + mp_srcptr up, vp; + mp_bitcnt_t c; + + un = u->_mp_size; + vn = v->_mp_size; + + if ( (un ^ vn) < 0) + return ~(mp_bitcnt_t) 0; + + comp = - (uc = vc = (un < 0)); + if (uc) + { + assert (vn < 0); + un = -un; + vn = -vn; + } + + up = u->_mp_d; + vp = v->_mp_d; + + if (un < vn) + MPN_SRCPTR_SWAP (up, un, vp, vn); + + for (i = 0, c = 0; i < vn; i++) + { + ul = (up[i] ^ comp) + uc; + uc = ul < uc; + + vl = (vp[i] ^ comp) + vc; + vc = vl < vc; + + c += gmp_popcount_limb (ul ^ vl); + } + assert (vc == 0); + + for (; i < un; i++) + { + ul = (up[i] ^ comp) + uc; + uc = ul < uc; + + c += gmp_popcount_limb (ul ^ comp); + } + + return c; +} + +mp_bitcnt_t +mpz_scan1 (const mpz_t u, mp_bitcnt_t starting_bit) +{ + mp_ptr up; + mp_size_t us, un, i; + mp_limb_t limb, ux; + + us = u->_mp_size; + un = GMP_ABS (us); + i = starting_bit / GMP_LIMB_BITS; + + /* Past the end there's no 1 bits for u>=0, or an immediate 1 bit + for u<0. Notice this test picks up any u==0 too. */ + if (i >= un) + return (us >= 0 ? ~(mp_bitcnt_t) 0 : starting_bit); + + up = u->_mp_d; + ux = 0; + limb = up[i]; + + if (starting_bit != 0) + { + if (us < 0) + { + ux = mpn_zero_p (up, i); + limb = ~ limb + ux; + ux = - (mp_limb_t) (limb >= ux); + } + + /* Mask to 0 all bits before starting_bit, thus ignoring them. */ + limb &= (GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS)); + } + + return mpn_common_scan (limb, i, up, un, ux); +} + +mp_bitcnt_t +mpz_scan0 (const mpz_t u, mp_bitcnt_t starting_bit) +{ + mp_ptr up; + mp_size_t us, un, i; + mp_limb_t limb, ux; + + us = u->_mp_size; + ux = - (mp_limb_t) (us >= 0); + un = GMP_ABS (us); + i = starting_bit / GMP_LIMB_BITS; + + /* When past end, there's an immediate 0 bit for u>=0, or no 0 bits for + u<0. Notice this test picks up all cases of u==0 too. */ + if (i >= un) + return (ux ? starting_bit : ~(mp_bitcnt_t) 0); + + up = u->_mp_d; + limb = up[i] ^ ux; + + if (ux == 0) + limb -= mpn_zero_p (up, i); /* limb = ~(~limb + zero_p) */ + + /* Mask all bits before starting_bit, thus ignoring them. */ + limb &= (GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS)); + + return mpn_common_scan (limb, i, up, un, ux); +} + + +/* MPZ base conversion. */ + +size_t +mpz_sizeinbase (const mpz_t u, int base) +{ + mp_size_t un; + mp_srcptr up; + mp_ptr tp; + mp_bitcnt_t bits; + struct gmp_div_inverse bi; + size_t ndigits; + + assert (base >= 2); + assert (base <= 36); + + un = GMP_ABS (u->_mp_size); + if (un == 0) + return 1; + + up = u->_mp_d; + + bits = (un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1]); + switch (base) + { + case 2: + return bits; + case 4: + return (bits + 1) / 2; + case 8: + return (bits + 2) / 3; + case 16: + return (bits + 3) / 4; + case 32: + return (bits + 4) / 5; + /* FIXME: Do something more clever for the common case of base + 10. */ + } + + tp = gmp_xalloc_limbs (un); + mpn_copyi (tp, up, un); + mpn_div_qr_1_invert (&bi, base); + + ndigits = 0; + do + { + ndigits++; + mpn_div_qr_1_preinv (tp, tp, un, &bi); + un -= (tp[un-1] == 0); + } + while (un > 0); + + gmp_free (tp); + return ndigits; +} + +char * +mpz_get_str (char *sp, int base, const mpz_t u) +{ + unsigned bits; + const char *digits; + mp_size_t un; + size_t i, sn; + + if (base >= 0) + { + digits = "0123456789abcdefghijklmnopqrstuvwxyz"; + } + else + { + base = -base; + digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + } + if (base <= 1) + base = 10; + if (base > 36) + return NULL; + + sn = 1 + mpz_sizeinbase (u, base); + if (!sp) + sp = (char *) gmp_xalloc (1 + sn); + + un = GMP_ABS (u->_mp_size); + + if (un == 0) + { + sp[0] = '0'; + sp[1] = '\0'; + return sp; + } + + i = 0; + + if (u->_mp_size < 0) + sp[i++] = '-'; + + bits = mpn_base_power_of_two_p (base); + + if (bits) + /* Not modified in this case. */ + sn = i + mpn_get_str_bits ((unsigned char *) sp + i, bits, u->_mp_d, un); + else + { + struct mpn_base_info info; + mp_ptr tp; + + mpn_get_base_info (&info, base); + tp = gmp_xalloc_limbs (un); + mpn_copyi (tp, u->_mp_d, un); + + sn = i + mpn_get_str_other ((unsigned char *) sp + i, base, &info, tp, un); + gmp_free (tp); + } + + for (; i < sn; i++) + sp[i] = digits[(unsigned char) sp[i]]; + + sp[sn] = '\0'; + return sp; +} + +int +mpz_set_str (mpz_t r, const char *sp, int base) +{ + unsigned bits; + mp_size_t rn, alloc; + mp_ptr rp; + size_t dn; + int sign; + unsigned char *dp; + + assert (base == 0 || (base >= 2 && base <= 36)); + + while (isspace( (unsigned char) *sp)) + sp++; + + sign = (*sp == '-'); + sp += sign; + + if (base == 0) + { + if (sp[0] == '0') + { + if (sp[1] == 'x' || sp[1] == 'X') + { + base = 16; + sp += 2; + } + else if (sp[1] == 'b' || sp[1] == 'B') + { + base = 2; + sp += 2; + } + else + base = 8; + } + else + base = 10; + } + + if (!*sp) + { + r->_mp_size = 0; + return -1; + } + dp = (unsigned char *) gmp_xalloc (strlen (sp)); + + for (dn = 0; *sp; sp++) + { + unsigned digit; + + if (isspace ((unsigned char) *sp)) + continue; + else if (*sp >= '0' && *sp <= '9') + digit = *sp - '0'; + else if (*sp >= 'a' && *sp <= 'z') + digit = *sp - 'a' + 10; + else if (*sp >= 'A' && *sp <= 'Z') + digit = *sp - 'A' + 10; + else + digit = base; /* fail */ + + if (digit >= (unsigned) base) + { + gmp_free (dp); + r->_mp_size = 0; + return -1; + } + + dp[dn++] = digit; + } + + if (!dn) + { + gmp_free (dp); + r->_mp_size = 0; + return -1; + } + bits = mpn_base_power_of_two_p (base); + + if (bits > 0) + { + alloc = (dn * bits + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS; + rp = MPZ_REALLOC (r, alloc); + rn = mpn_set_str_bits (rp, dp, dn, bits); + } + else + { + struct mpn_base_info info; + mpn_get_base_info (&info, base); + alloc = (dn + info.exp - 1) / info.exp; + rp = MPZ_REALLOC (r, alloc); + rn = mpn_set_str_other (rp, dp, dn, base, &info); + /* Normalization, needed for all-zero input. */ + assert (rn > 0); + rn -= rp[rn-1] == 0; + } + assert (rn <= alloc); + gmp_free (dp); + + r->_mp_size = sign ? - rn : rn; + + return 0; +} + +int +mpz_init_set_str (mpz_t r, const char *sp, int base) +{ + mpz_init (r); + return mpz_set_str (r, sp, base); +} + +size_t +mpz_out_str (FILE *stream, int base, const mpz_t x) +{ + char *str; + size_t len; + + str = mpz_get_str (NULL, base, x); + len = strlen (str); + len = fwrite (str, 1, len, stream); + gmp_free (str); + return len; +} + + +static int +gmp_detect_endian (void) +{ + static const int i = 2; + const unsigned char *p = (const unsigned char *) &i; + return 1 - *p; +} + +/* Import and export. Does not support nails. */ +void +mpz_import (mpz_t r, size_t count, int order, size_t size, int endian, + size_t nails, const void *src) +{ + const unsigned char *p; + ptrdiff_t word_step; + mp_ptr rp; + mp_size_t rn; + + /* The current (partial) limb. */ + mp_limb_t limb; + /* The number of bytes already copied to this limb (starting from + the low end). */ + size_t bytes; + /* The index where the limb should be stored, when completed. */ + mp_size_t i; + + if (nails != 0) + gmp_die ("mpz_import: Nails not supported."); + + assert (order == 1 || order == -1); + assert (endian >= -1 && endian <= 1); + + if (endian == 0) + endian = gmp_detect_endian (); + + p = (unsigned char *) src; + + word_step = (order != endian) ? 2 * size : 0; + + /* Process bytes from the least significant end, so point p at the + least significant word. */ + if (order == 1) + { + p += size * (count - 1); + word_step = - word_step; + } + + /* And at least significant byte of that word. */ + if (endian == 1) + p += (size - 1); + + rn = (size * count + sizeof(mp_limb_t) - 1) / sizeof(mp_limb_t); + rp = MPZ_REALLOC (r, rn); + + for (limb = 0, bytes = 0, i = 0; count > 0; count--, p += word_step) + { + size_t j; + for (j = 0; j < size; j++, p -= (ptrdiff_t) endian) + { + limb |= (mp_limb_t) *p << (bytes++ * CHAR_BIT); + if (bytes == sizeof(mp_limb_t)) + { + rp[i++] = limb; + bytes = 0; + limb = 0; + } + } + } + assert (i + (bytes > 0) == rn); + if (limb != 0) + rp[i++] = limb; + else + i = mpn_normalized_size (rp, i); + + r->_mp_size = i; +} + +void * +mpz_export (void *r, size_t *countp, int order, size_t size, int endian, + size_t nails, const mpz_t u) +{ + size_t count; + mp_size_t un; + + if (nails != 0) + gmp_die ("mpz_import: Nails not supported."); + + assert (order == 1 || order == -1); + assert (endian >= -1 && endian <= 1); + assert (size > 0 || u->_mp_size == 0); + + un = u->_mp_size; + count = 0; + if (un != 0) + { + size_t k; + unsigned char *p; + ptrdiff_t word_step; + /* The current (partial) limb. */ + mp_limb_t limb; + /* The number of bytes left to to in this limb. */ + size_t bytes; + /* The index where the limb was read. */ + mp_size_t i; + + un = GMP_ABS (un); + + /* Count bytes in top limb. */ + limb = u->_mp_d[un-1]; + assert (limb != 0); + + k = 0; + do { + k++; limb >>= CHAR_BIT; + } while (limb != 0); + + count = (k + (un-1) * sizeof (mp_limb_t) + size - 1) / size; + + if (!r) + r = gmp_xalloc (count * size); + + if (endian == 0) + endian = gmp_detect_endian (); + + p = (unsigned char *) r; + + word_step = (order != endian) ? 2 * size : 0; + + /* Process bytes from the least significant end, so point p at the + least significant word. */ + if (order == 1) + { + p += size * (count - 1); + word_step = - word_step; + } + + /* And at least significant byte of that word. */ + if (endian == 1) + p += (size - 1); + + for (bytes = 0, i = 0, k = 0; k < count; k++, p += word_step) + { + size_t j; + for (j = 0; j < size; j++, p -= (ptrdiff_t) endian) + { + if (bytes == 0) + { + if (i < un) + limb = u->_mp_d[i++]; + bytes = sizeof (mp_limb_t); + } + *p = limb; + limb >>= CHAR_BIT; + bytes--; + } + } + assert (i == un); + assert (k == count); + } + + if (countp) + *countp = count; + + return r; +} diff --git a/Qt-Secret/src/GMP/mini-gmp.h b/Qt-Secret/src/GMP/mini-gmp.h new file mode 100644 index 0000000..44ef5f5 --- /dev/null +++ b/Qt-Secret/src/GMP/mini-gmp.h @@ -0,0 +1,303 @@ +/* mini-gmp, a minimalistic implementation of a GNU GMP subset. + +Copyright 2011-2015 Free Software Foundation, Inc. + +This file is part of the GNU MP Library. + +The GNU MP Library is free software; you can redistribute it and/or modify +it under the terms of either: + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your + option) any later version. + +or + + * the GNU General Public License as published by the Free Software + Foundation; either version 2 of the License, or (at your option) any + later version. + +or both in parallel, as here. + +The GNU MP Library is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received copies of the GNU General Public License and the +GNU Lesser General Public License along with the GNU MP Library. If not, +see https://www.gnu.org/licenses/. */ + +/* About mini-gmp: This is a minimal implementation of a subset of the + GMP interface. It is intended for inclusion into applications which + have modest bignums needs, as a fallback when the real GMP library + is not installed. + + This file defines the public interface. */ + +#ifndef MINI_GMP +#define MINI_GMP + +/* For size_t */ +#include + +#if defined (__cplusplus) +extern "C" { +#endif + +#define UN_USED(X) (void)X + +void mp_set_memory_functions (void *(*) (size_t), + void *(*) (void *, size_t, size_t), + void (*) (void *, size_t)); + +void mp_get_memory_functions (void *(**) (size_t), + void *(**) (void *, size_t, size_t), + void (**) (void *, size_t)); + +typedef unsigned long long uIntMpz; +typedef long long intMpz; + +typedef uIntMpz mp_limb_t; +typedef intMpz mp_size_t; +typedef uIntMpz mp_bitcnt_t; + +typedef mp_limb_t *mp_ptr; +typedef const mp_limb_t *mp_srcptr; + +typedef struct +{ + int _mp_alloc; /* Number of *limbs* allocated and pointed + to by the _mp_d field. */ + int _mp_size; /* abs(_mp_size) is the number of limbs the + last field points to. If _mp_size is + negative this is a negative number. */ + mp_limb_t *_mp_d; /* Pointer to the limbs. */ +} __mpz_struct; + +typedef __mpz_struct mpz_t[1]; + +typedef __mpz_struct *mpz_ptr; +typedef const __mpz_struct *mpz_srcptr; + +extern const int mp_bits_per_limb; + +void mpn_copyi (mp_ptr, mp_srcptr, mp_size_t); +void mpn_copyd (mp_ptr, mp_srcptr, mp_size_t); +void mpn_zero (mp_ptr, mp_size_t); + +int mpn_cmp (mp_srcptr, mp_srcptr, mp_size_t); +int mpn_zero_p (mp_srcptr, mp_size_t); + +mp_limb_t mpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t); +mp_limb_t mpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t); +mp_limb_t mpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t); + +mp_limb_t mpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t); +mp_limb_t mpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t); +mp_limb_t mpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t); + +mp_limb_t mpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t); +mp_limb_t mpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t); +mp_limb_t mpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t); + +mp_limb_t mpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t); +void mpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t); +void mpn_sqr (mp_ptr, mp_srcptr, mp_size_t); +int mpn_perfect_square_p (mp_srcptr, mp_size_t); +mp_size_t mpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t); + +mp_limb_t mpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int); +mp_limb_t mpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int); + +mp_bitcnt_t mpn_scan0 (mp_srcptr, mp_bitcnt_t); +mp_bitcnt_t mpn_scan1 (mp_srcptr, mp_bitcnt_t); + +void mpn_com (mp_ptr, mp_srcptr, mp_size_t); +mp_limb_t mpn_neg (mp_ptr, mp_srcptr, mp_size_t); + +mp_bitcnt_t mpn_popcount (mp_srcptr, mp_size_t); + +mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t); +#define mpn_invert_limb(x) mpn_invert_3by2 ((x), 0) + +size_t mpn_get_str (unsigned char *, int, mp_ptr, mp_size_t); +mp_size_t mpn_set_str (mp_ptr, const unsigned char *, size_t, int); + +void mpz_init (mpz_t); +void mpz_init2 (mpz_t, mp_bitcnt_t); +void mpz_clear (mpz_t); + +#define mpz_odd_p(z) (((z)->_mp_size != 0) & (int) (z)->_mp_d[0]) +#define mpz_even_p(z) (! mpz_odd_p (z)) + +int mpz_sgn (const mpz_t); +int mpz_cmp_si (const mpz_t, intMpz); +int mpz_cmp_ui (const mpz_t, uIntMpz); +int mpz_cmp (const mpz_t, const mpz_t); +int mpz_cmpabs_ui (const mpz_t, uIntMpz); +int mpz_cmpabs (const mpz_t, const mpz_t); +int mpz_cmp_d (const mpz_t, double); +int mpz_cmpabs_d (const mpz_t, double); + +void mpz_abs (mpz_t, const mpz_t); +void mpz_neg (mpz_t, const mpz_t); +void mpz_swap (mpz_t, mpz_t); + +void mpz_add_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_add (mpz_t, const mpz_t, const mpz_t); +void mpz_sub_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_ui_sub (mpz_t, uIntMpz, const mpz_t); +void mpz_sub (mpz_t, const mpz_t, const mpz_t); + +void mpz_mul_si (mpz_t, const mpz_t, intMpz); +void mpz_mul_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_mul (mpz_t, const mpz_t, const mpz_t); +void mpz_mul_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_addmul_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_addmul (mpz_t, const mpz_t, const mpz_t); +void mpz_submul_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_submul (mpz_t, const mpz_t, const mpz_t); + +void mpz_cdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t); +void mpz_fdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t); +void mpz_tdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t); +void mpz_cdiv_q (mpz_t, const mpz_t, const mpz_t); +void mpz_fdiv_q (mpz_t, const mpz_t, const mpz_t); +void mpz_tdiv_q (mpz_t, const mpz_t, const mpz_t); +void mpz_cdiv_r (mpz_t, const mpz_t, const mpz_t); +void mpz_fdiv_r (mpz_t, const mpz_t, const mpz_t); +void mpz_tdiv_r (mpz_t, const mpz_t, const mpz_t); + +void mpz_cdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_fdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_tdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_cdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_fdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t); +void mpz_tdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t); + +void mpz_mod (mpz_t, const mpz_t, const mpz_t); + +void mpz_divexact (mpz_t, const mpz_t, const mpz_t); + +int mpz_divisible_p (const mpz_t, const mpz_t); +int mpz_congruent_p (const mpz_t, const mpz_t, const mpz_t); + +uIntMpz mpz_cdiv_qr_ui (mpz_t, mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_fdiv_qr_ui (mpz_t, mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_tdiv_qr_ui (mpz_t, mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_cdiv_q_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_fdiv_q_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_tdiv_q_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_cdiv_r_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_fdiv_r_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_tdiv_r_ui (mpz_t, const mpz_t, uIntMpz); +uIntMpz mpz_cdiv_ui (const mpz_t, uIntMpz); +uIntMpz mpz_fdiv_ui (const mpz_t, uIntMpz); +uIntMpz mpz_tdiv_ui (const mpz_t, uIntMpz); + +uIntMpz mpz_mod_ui (mpz_t, const mpz_t, uIntMpz); + +void mpz_divexact_ui (mpz_t, const mpz_t, uIntMpz); + +int mpz_divisible_ui_p (const mpz_t, uIntMpz); + +uIntMpz mpz_gcd_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_gcd (mpz_t, const mpz_t, const mpz_t); +void mpz_gcdext (mpz_t, mpz_t, mpz_t, const mpz_t, const mpz_t); +void mpz_lcm_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_lcm (mpz_t, const mpz_t, const mpz_t); +int mpz_invert (mpz_t, const mpz_t, const mpz_t); + +void mpz_sqrtrem (mpz_t, mpz_t, const mpz_t); +void mpz_sqrt (mpz_t, const mpz_t); +int mpz_perfect_square_p (const mpz_t); + +void mpz_pow_ui (mpz_t, const mpz_t, uIntMpz); +void mpz_ui_pow_ui (mpz_t, uIntMpz, uIntMpz); +void mpz_powm (mpz_t, const mpz_t, const mpz_t, const mpz_t); +void mpz_powm_ui (mpz_t, const mpz_t, uIntMpz, const mpz_t); + +void mpz_rootrem (mpz_t, mpz_t, const mpz_t, uIntMpz); +int mpz_root (mpz_t, const mpz_t, uIntMpz); + +void mpz_fac_ui (mpz_t, uIntMpz); +void mpz_bin_uiui (mpz_t, uIntMpz, uIntMpz); + +int mpz_probab_prime_p (const mpz_t, int); + +int mpz_tstbit (const mpz_t, mp_bitcnt_t); +void mpz_setbit (mpz_t, mp_bitcnt_t); +void mpz_clrbit (mpz_t, mp_bitcnt_t); +void mpz_combit (mpz_t, mp_bitcnt_t); + +void mpz_com (mpz_t, const mpz_t); +void mpz_and (mpz_t, const mpz_t, const mpz_t); +void mpz_ior (mpz_t, const mpz_t, const mpz_t); +void mpz_xor (mpz_t, const mpz_t, const mpz_t); + +mp_bitcnt_t mpz_popcount (const mpz_t); +mp_bitcnt_t mpz_hamdist (const mpz_t, const mpz_t); +mp_bitcnt_t mpz_scan0 (const mpz_t, mp_bitcnt_t); +mp_bitcnt_t mpz_scan1 (const mpz_t, mp_bitcnt_t); + +int mpz_fits_slong_p (const mpz_t); +int mpz_fits_ulong_p (const mpz_t); +intMpz mpz_get_si (const mpz_t); +uIntMpz mpz_get_ui (const mpz_t); +double mpz_get_d (const mpz_t); +size_t mpz_size (const mpz_t); +mp_limb_t mpz_getlimbn (const mpz_t, mp_size_t); + +void mpz_realloc2 (mpz_t, mp_bitcnt_t); +mp_srcptr mpz_limbs_read (mpz_srcptr); +mp_ptr mpz_limbs_modify (mpz_t, mp_size_t); +mp_ptr mpz_limbs_write (mpz_t, mp_size_t); +void mpz_limbs_finish (mpz_t, mp_size_t); +mpz_srcptr mpz_roinit_n (mpz_t, mp_srcptr, mp_size_t); + +#define MPZ_ROINIT_N(xp, xs) {{0, (xs),(xp) }} + +void mpz_set_si (mpz_t, intMpz); +void mpz_set_ui (mpz_t, uIntMpz); +void mpz_set (mpz_t, const mpz_t); +void mpz_set_d (mpz_t, double); + +void mpz_init_set_si (mpz_t, intMpz); +void mpz_init_set_ui (mpz_t, uIntMpz); +void mpz_init_set (mpz_t, const mpz_t); +void mpz_init_set_d (mpz_t, double); + +size_t mpz_sizeinbase (const mpz_t, int); +char *mpz_get_str (char *, int, const mpz_t); +int mpz_set_str (mpz_t, const char *, int); +int mpz_init_set_str (mpz_t, const char *, int); + +/* This long list taken from gmp.h. */ +/* For reference, "defined(EOF)" cannot be used here. In g++ 2.95.4, + defines EOF but not FILE. */ +#if defined (FILE) \ + || defined (H_STDIO) \ + || defined (_H_STDIO) /* AIX */ \ + || defined (_STDIO_H) /* glibc, Sun, SCO */ \ + || defined (_STDIO_H_) /* BSD, OSF */ \ + || defined (__STDIO_H) /* Borland */ \ + || defined (__STDIO_H__) /* IRIX */ \ + || defined (_STDIO_INCLUDED) /* HPUX */ \ + || defined (__dj_include_stdio_h_) /* DJGPP */ \ + || defined (_FILE_DEFINED) /* Microsoft */ \ + || defined (__STDIO__) /* Apple MPW MrC */ \ + || defined (_MSL_STDIO_H) /* Metrowerks */ \ + || defined (_STDIO_H_INCLUDED) /* QNX4 */ \ + || defined (_ISO_STDIO_ISO_H) /* Sun C++ */ \ + || defined (__STDIO_LOADED) /* VMS */ +size_t mpz_out_str (FILE *, int, const mpz_t); +#endif + +void mpz_import (mpz_t, size_t, int, size_t, int, size_t, const void *); +void *mpz_export (void *, size_t *, int, size_t, int, size_t, const mpz_t); + +#if defined (__cplusplus) +} +#endif +#endif /* MINI_GMP */ diff --git a/Qt-Secret/src/GMP/minigmp_global.h b/Qt-Secret/src/GMP/minigmp_global.h new file mode 100644 index 0000000..5757875 --- /dev/null +++ b/Qt-Secret/src/GMP/minigmp_global.h @@ -0,0 +1,21 @@ +//# +//# Copyright (C) 2018-2019 QuasarApp. +//# Distributed under the lgplv3 software license, see the accompanying +//# Everyone is permitted to copy and distribute verbatim copies +//# of this license document, but changing it is not allowed. +//# + +#ifndef MINIGMP_GLOBAL_H +#define MINIGMP_GLOBAL_H + +#ifdef _WIN32 +# define MINIGMPSHARED_EXPORT __declspec(dllexport) +#endif + +#ifdef linux +# define MINIGMPSHARED_EXPORT __attribute__((visibility("default"))) +#endif + + + +#endif //MINIGMP_GLOBAL_H diff --git a/Qt-Secret/src/Qt-RSA/qrsaencryption.cpp b/Qt-Secret/src/Qt-RSA/qrsaencryption.cpp new file mode 100644 index 0000000..01a3344 --- /dev/null +++ b/Qt-Secret/src/Qt-RSA/qrsaencryption.cpp @@ -0,0 +1,403 @@ +//# +//# Copyright (C) 2018-2019 QuasarApp. +//# Distributed under the lgplv3 software license, see the accompanying +//# Everyone is permitted to copy and distribute verbatim copies +//# of this license document, but changing it is not allowed. +//# + +#include "qrsaencryption.h" + +#include +#include +#include +#include + +#define KEY_GEN_LIMIT 10 + +const QString SIGN_MARKER = "-SIGN-"; +const int signMarkerLength = SIGN_MARKER.length(); + +QRSAEncryption::INT eulerFunc(const QRSAEncryption::INT &p, const QRSAEncryption::INT &q) { + return (p - 1) * (q - 1); +} + +bool QRSAEncryption::isMutuallyPrime(const INT &a, const INT &b) { + if ( (!(a % 2) && !(b % 2)) + || (!(a % 3) && !(b % 3)) + || (!(a % 5) && !(b % 5)) + || (!(a % 7) && !(b % 7)) + ) return false; + + return INT().gcd(a, b) == 1; +} + +QRSAEncryption::Rsa QRSAEncryption::getBitsSize(const INT &i) const { + int rsaBits = RSA_64; + int intBits = i.sizeBits(); + + while (rsaBits < intBits) { + rsaBits *= 2; + } + + return static_cast(rsaBits); + +} + +QRSAEncryption::Rsa QRSAEncryption::getBitsSize(const QByteArray &key) const { + if (isValidRsaKey(key)) { + return static_cast(key.size() * 4); + } + + return QRSAEncryption::Rsa::Invalid; +} + +QRSAEncryption::INT QRSAEncryption::fromArray(const QByteArray &array) const { + INT res = 0; + res.fromHex(array.toHex().toStdString()); + return res; +} + +QByteArray QRSAEncryption::toArray(const INT &i, short sizeBlok) { + QByteArray res; + res = QByteArray::fromHex(QByteArray::fromStdString(i.getString(16))); + + if (sizeBlok < 0) { + return res; + } + + while (res.size() < sizeBlok) { + res.push_front(char(0)); + } + + return res.left(sizeBlok); +} + +QRSAEncryption::INT QRSAEncryption::randomNumber(bool fullFill) const { + + srand(std::chrono::duration_cast + (std::chrono::system_clock::now().time_since_epoch()).count() + % std::numeric_limits::max()); + + INT res{1}; + + if(fullFill) { + + while(res.longBits() < _rsa) { + res *= (rand() % (std::numeric_limits::max() - 1)) + 1; + } + } else { + + int longDiff = _rsa / (sizeof (int) * 8); + + while (longDiff > 0) { + longDiff--; + res *= (rand() % (std::numeric_limits::max() - 1)) + 1; + } + } + + return res; +} + +QRSAEncryption::INT QRSAEncryption::toPrime(INT n) const { + if (!(n % 2)) { + ++n; + } + + INT LN = n; + INT RN = n; + + while (true) { + + if (LN.isPrime(false)) return LN; + + RN+=2; + + if (RN.isPrime(false)) return RN; + LN-=2; + } +} + +QRSAEncryption::INT QRSAEncryption::randomPrimeNumber(INT no) const { + srand(static_cast(time(nullptr))); + + // max INT + INT max('1', _rsa / 2, 2); + + auto p = toPrime(randomNumber() % max); + while(p == no) p = toPrime(randomNumber() % max); + + return p; +} + +QRSAEncryption::INT QRSAEncryption::extEuclid(INT a, INT b) const { + INT x = 0, y = 1, u = 1, v = 0, gcd = b, m, n, q, r; + while (a != 0) { + q = gcd / a; + r = gcd % a; + m = x - u * q; + n = y - v * q; + gcd = a; + a = r; + x = u; + y = v; + u = m; + v = n; + } + return y; +} + +short QRSAEncryption::getBlockSize(INT i) const { + return static_cast(i.longBytes()) - 1; +} + +QByteArray QRSAEncryption::encodeBlok(const INT &block, const INT &e, const INT &m, short blockSize) { + + return toArray(INT::powm(block, e, m), blockSize); +} + +QByteArray QRSAEncryption::decodeBlok(const INT &block, const INT &d, const INT &m, short blockSize) { + + return toArray(INT::powm(block, d, m), blockSize); +} + +QRSAEncryption::QRSAEncryption(Rsa rsa) { + _rsa = rsa; +} + +bool QRSAEncryption::generatePairKeyS(QByteArray &pubKey, QByteArray &privKey, QRSAEncryption::Rsa rsa) { + qWarning() << "method " << Q_FUNC_INFO << + " will be deleted in newxt version. please use generatePairKey method"; + return generatePairKey(pubKey, privKey, rsa); +} + +QByteArray QRSAEncryption::encodeS(const QByteArray &rawData, const QByteArray &pubKey, QRSAEncryption::Rsa rsa, QRSAEncryption::BlockSize blockSizeMode) { + qWarning() << "method " << Q_FUNC_INFO << + " will be deleted in newxt version. please use encode method"; + return encode(rawData, pubKey, rsa, blockSizeMode); + +} + +QByteArray QRSAEncryption::decodeS(const QByteArray &rawData, const QByteArray &privKey, QRSAEncryption::Rsa rsa, QRSAEncryption::BlockSize blockSizeMode) { + qWarning() << "method " << Q_FUNC_INFO << + " will be deleted in newxt version. please use decode method"; + return decode(rawData, privKey, rsa, blockSizeMode); + +} + +QByteArray QRSAEncryption::signMessageS(QByteArray rawData, const QByteArray &privKey, QRSAEncryption::Rsa rsa) { + qWarning() << "method " << Q_FUNC_INFO << + " will be deleted in newxt version. please use signMessage method"; + return signMessage(rawData, privKey, rsa); + +} + +bool QRSAEncryption::checkSignMessageS(const QByteArray &rawData, const QByteArray &pubKey, QRSAEncryption::Rsa rsa) { + qWarning() << "method " << Q_FUNC_INFO << + " will be deleted in newxt version. please use signMessage method"; + return checkSignMessage(rawData, pubKey, rsa); +} + +unsigned int QRSAEncryption::getKeyBytesSize(QRSAEncryption::Rsa rsa) { + + return rsa / 4; +} + +// --- static methods --- +bool QRSAEncryption::generatePairKey(QByteArray &pubKey, QByteArray &privKey, + QRSAEncryption::Rsa rsa) { + + return QRSAEncryption(rsa).generatePairKey(pubKey, privKey); +} + +QByteArray QRSAEncryption::encode(const QByteArray &rawData, const QByteArray &pubKey, + Rsa rsa, BlockSize blockSizeMode) { + + return QRSAEncryption(rsa).encode(rawData, pubKey, blockSizeMode); +} + +QByteArray QRSAEncryption::decode(const QByteArray &rawData, const QByteArray &privKey, + Rsa rsa, BlockSize blockSizeMode) { + + return QRSAEncryption(rsa).decode(rawData, privKey, blockSizeMode); +} + +QByteArray QRSAEncryption::signMessage(QByteArray rawData, const QByteArray &privKey, Rsa rsa) { + + return QRSAEncryption(rsa).signMessage(rawData, privKey); +} + +bool QRSAEncryption::checkSignMessage(const QByteArray &rawData, const QByteArray &pubKey, Rsa rsa) { + + return QRSAEncryption(rsa).checkSignMessage(rawData, pubKey); +} + +// --- end of static methods --- + +bool QRSAEncryption::generatePairKey(QByteArray &pubKey, QByteArray &privKey) { + + int cnt{0}; + bool keyGenRes{false}; + INT p, q, modul, eilor, e, d; + do { + + pubKey.clear(); + privKey.clear(); + + p = randomPrimeNumber(); + q = randomPrimeNumber(p); + + modul = 0; + while ((modul = p * q) < 0) { + p = toPrime((p - 1) / 2); + } + + eilor = eulerFunc(p, q); + e = randomNumber() % eilor; + + if (!(e % 2)) --e; + + do { + e -= 2; + } while((!isMutuallyPrime(eilor, e))); + + d = extEuclid(eilor , e); + + while(d < 0 ) { + d += eilor; + } + + pubKey.append(toArray(e, _rsa / 8)); + pubKey.append(toArray(modul, _rsa / 8)); + privKey.append(toArray(d, _rsa / 8)); + privKey.append(toArray(modul, _rsa / 8)); + + } while (!(keyGenRes = testKeyPair(pubKey, privKey)) && (++cnt < KEY_GEN_LIMIT)); + + if(cnt >= KEY_GEN_LIMIT) qWarning() << QString("(Warning): Exceeded limit of key generation (%0)!").arg(KEY_GEN_LIMIT); + + return (keyGenRes && cnt < KEY_GEN_LIMIT); +} + +// --- non-static methods --- +QByteArray QRSAEncryption::encode(const QByteArray &rawData, const QByteArray &pubKey, BlockSize blockSizeMode) { + + if (getBitsSize(pubKey) != _rsa) { + return QByteArray(); + } + + int index = 0; + + QByteArray block; + + INT e = fromArray(pubKey.mid(0, pubKey.size() / 2)); + INT m = fromArray(pubKey.mid(pubKey.size() / 2)); + + short blockSizeOut = getBlockSize(m) + 1; // BlockSize::OneByte + short blockSizeIn = 1; // BlockSize::OneByte + + if (blockSizeMode == BlockSize::Auto) { + blockSizeIn = getBlockSize(m); + } + + if (!blockSizeIn) { + qDebug() << "module of key small! size = 1 byte, 2 byte is minimum"; + return QByteArray(); + } + + QByteArray res; + + while ((block = rawData.mid(index, blockSizeIn)).size()) { + + if (index + blockSizeIn > rawData.size() && block.size() && !block[0]) { + qWarning() << "When trying to encrypt data, problems arose, the last block contains non-significant zeros." + " These zeros will be deleted during the decryption process." + " For encode and decode data with non-significant zeros use BlockSize::OneByte"; + } + + res.append(encodeBlok(fromArray(block), e, m, blockSizeOut)); + index += blockSizeIn; + } + + return res; + +} +QByteArray QRSAEncryption::decode(const QByteArray &rawData, const QByteArray &privKey, BlockSize blockSizeMode) { + + if (getBitsSize(privKey) != _rsa) { + return QByteArray(); + } + + int index = 0; + + QByteArray block; + + INT d = fromArray(privKey.mid(0, privKey.size() / 2)); + INT m = fromArray(privKey.mid(privKey.size() / 2)); + + short blockSizeIn = getBlockSize(m) + 1; + + short blockSizeOut = 1; // BlockSize::OneByte + if (blockSizeMode == BlockSize::Auto) { + blockSizeOut = getBlockSize(m); + } + + QByteArray res; + while ((block = rawData.mid(index, blockSizeIn)).size()) { + bool isLastBlock = (index + blockSizeIn) >= rawData.size(); + + res.append(decodeBlok(fromArray(block), d, m, + (isLastBlock && blockSizeMode == BlockSize::Auto)? -1 : blockSizeOut)); + index += blockSizeIn; + } + return res; + +} +QByteArray QRSAEncryption::signMessage(QByteArray rawData, const QByteArray &privKey) { + + QByteArray hash = QCryptographicHash::hash(rawData, HashAlgorithm::Sha256); + + QByteArray signature = encode(hash, privKey, BlockSize::OneByte); + + rawData.append(SIGN_MARKER + signature.toHex() + SIGN_MARKER); + + return rawData; +} +bool QRSAEncryption::checkSignMessage(const QByteArray &rawData, const QByteArray &pubKey) { + + // start position of SIGN_MARKER in rawData + auto signStartPos = rawData.lastIndexOf(SIGN_MARKER, rawData.length() - signMarkerLength - 1); + + // length of signature in rawData + auto signLength = rawData.length() - signStartPos - signMarkerLength * 2; + + // message, that was recieved from channel + QByteArray message = rawData.left(signStartPos); + + // hash, that was decrypt from recieved signature + QByteArray recievedHash = decode(QByteArray::fromHex(rawData.mid(signStartPos + signMarkerLength, signLength)), + pubKey, BlockSize::OneByte); + + // if recievedHash == hashAlgorithm(recived message), then signed message is valid + return recievedHash == QCryptographicHash::hash(message, HashAlgorithm::Sha256); +} + +QRSAEncryption::Rsa QRSAEncryption::getRsa() const { + return _rsa; +} + +bool QRSAEncryption::testKeyPair(const QByteArray &pubKey, const QByteArray &privKey) { + + QByteArray tesVal = "Test message of encrypkey"; + + bool result = tesVal == decode(encode(tesVal, pubKey), privKey); + + if (!result) qWarning() << "(Warning): Testkey Fail, try generate new key pair!"; + + return result; +} + +// --- end of non-static methods --- + +bool QRSAEncryption::isValidRsaKey(const QByteArray &key) { + return key.size() && ((static_cast(key.size()) % getKeyBytesSize(RSA_64)) == 0); +} diff --git a/Qt-Secret/src/Qt-RSA/qrsaencryption.h b/Qt-Secret/src/Qt-RSA/qrsaencryption.h new file mode 100644 index 0000000..6fdffb3 --- /dev/null +++ b/Qt-Secret/src/Qt-RSA/qrsaencryption.h @@ -0,0 +1,116 @@ +//# +//# Copyright (C) 2018-2019 QuasarApp. +//# Distributed under the lgplv3 software license, see the accompanying +//# Everyone is permitted to copy and distribute verbatim copies +//# of this license document, but changing it is not allowed. +//# + +#ifndef QRSAENCRYPTION_H +#define QRSAENCRYPTION_H + +#include +#include +#include +#include +#include +#include // to use sha256 +#include "./../qtsecret_global.h" + +#include + + +class Qt_SECRETSHARED_EXPORT QRSAEncryption +{ +public: + typedef BigInt INT; + typedef QCryptographicHash::Algorithm HashAlgorithm; + + enum Rsa { + Invalid = 0, + RSA_64 = 64, + RSA_128 = 128, + RSA_256 = 256, + RSA_512 = 512, + RSA_1024 = 1024, + RSA_2048 = 2048, + RSA_4096 = 4096, + RSA_8192 = 8192, + + }; + + enum BlockSize { + Auto = 0, // fast but not stable. (using by default) + OneByte = 1 // stable but slow. (using for sig and check sig messages) + }; + + + QRSAEncryption(Rsa rsa = Rsa::RSA_256); + +// static methods + + // OLDMETHODS DELETE IN next Version + static bool generatePairKeyS(QByteArray &pubKey, QByteArray &privKey, + QRSAEncryption::Rsa rsa = RSA_256); + static QByteArray encodeS(const QByteArray &rawData, const QByteArray &pubKey, + Rsa rsa = RSA_256, BlockSize blockSizeMode = BlockSize::Auto); + static QByteArray decodeS(const QByteArray &rawData, const QByteArray &privKey, + Rsa rsa = RSA_256, BlockSize blockSizeMode = BlockSize::Auto); + static QByteArray signMessageS(QByteArray rawData, const QByteArray &privKey, + Rsa rsa = RSA_256); + static bool checkSignMessageS(const QByteArray &rawData, const QByteArray &pubKey, + Rsa rsa); + // OLDMETHODS END + + static bool generatePairKey(QByteArray &pubKey, QByteArray &privKey, + QRSAEncryption::Rsa rsa); + static QByteArray encode(const QByteArray &rawData, const QByteArray &pubKey, + Rsa rsa, BlockSize blockSizeMode = BlockSize::Auto); + static QByteArray decode(const QByteArray &rawData, const QByteArray &privKey, + Rsa rsa, BlockSize blockSizeMode = BlockSize::Auto); + static QByteArray signMessage(QByteArray rawData, const QByteArray &privKey, + Rsa rsa); + static bool checkSignMessage(const QByteArray &rawData, const QByteArray &pubKey, + Rsa rsa); + static bool isValidRsaKey(const QByteArray& key); + static unsigned int getKeyBytesSize(QRSAEncryption::Rsa rsa); + +// non-static methods + bool generatePairKey(QByteArray &pubKey, QByteArray &privKey); + + QByteArray encode(const QByteArray &rawData, const QByteArray &pubKey, + BlockSize blockSizeMode = BlockSize::Auto); + + QByteArray decode(const QByteArray &rawData, const QByteArray &privKey, + BlockSize blockSizeMode = BlockSize::Auto); + + QByteArray signMessage(QByteArray rawData, const QByteArray &privKey); + + bool checkSignMessage(const QByteArray &rawData, const QByteArray &pubKey); + + Rsa getRsa() const; + +private: + + Rsa _rsa; + + bool testKeyPair(const QByteArray &pubKey, const QByteArray &privKey); + bool isMutuallyPrime(const INT &a, const INT &b); + Rsa getBitsSize(const INT& i) const; + Rsa getBitsSize(const QByteArray& array) const; + + INT fromArray(const QByteArray& array) const; + QByteArray toArray(const INT &i, short sizeBlok = -1); + INT randomNumber(bool fullFilled = true) const; + INT toPrime(INT) const; + INT randomPrimeNumber(INT no = 0) const; + INT extEuclid(INT a, INT b) const; + + short getBlockSize(INT i) const; + + QByteArray encodeBlok(const INT& block, const INT& e, const INT& m, short blockSize); + QByteArray decodeBlok(const INT& block, const INT& d, const INT& m, short blockSize); + + +}; + +#endif // QRSAENCRYPTION_H diff --git a/Qt-Secret/src/Qt-Secret.pri b/Qt-Secret/src/Qt-Secret.pri new file mode 100644 index 0000000..7818b93 --- /dev/null +++ b/Qt-Secret/src/Qt-Secret.pri @@ -0,0 +1,24 @@ +# +# Copyright (C) 2018-2019 QuasarApp. +# Distributed under the lgplv3 software license, see the accompanying +# Everyone is permitted to copy and distribute verbatim copies +# of this license document, but changing it is not allowed. +# + +!isEmpty(Qt_SECRET_LIB):error("Qt-Secret.pri already included") +Qt_SECRET_LIB = 1 + +#DEPENDS +CONFIG(release, debug|release): { + Qt_SECRET_LIB_OUTPUT_DIR="$$PWD/build/release" +} else { + Qt_SECRET_LIB_OUTPUT_DIR="$$PWD/build/debug" +} + +unix:LIBS += -L$$Qt_SECRET_LIB_OUTPUT_DIR -lQt-Secret + +win32:LIBS += -L$$Qt_SECRET_LIB_OUTPUT_DIR -lQt-Secret1 + +INCLUDEPATH += "$$PWD/Qt-RSA" + +include($$PWD/GMP/GMP.pri) diff --git a/Qt-Secret/src/Qt-Secret.pro b/Qt-Secret/src/Qt-Secret.pro new file mode 100644 index 0000000..84eeeca --- /dev/null +++ b/Qt-Secret/src/Qt-Secret.pro @@ -0,0 +1,36 @@ +# +# Copyright (C) 2018-2019 QuasarApp. +# Distributed under the lgplv3 software license, see the accompanying +# Everyone is permitted to copy and distribute verbatim copies +# of this license document, but changing it is not allowed. +# + +QT -= gui +CONFIG += c++11 + +TARGET = Qt-Secret +TEMPLATE = lib + +DEFINES += Qt_SECRET_LIBRARY +DEFINES += QT_DEPRECATED_WARNINGS + +#DEPENDS +CONFIG(release, debug|release): { + DESTDIR="$$PWD/../build/release" +} else { + DESTDIR="$$PWD/../build/debug" +} + +include($$PWD/GMP/GMP.pri) + +VERSION = 1.2.0 + +HEADERS += \ + qtsecret_global.h \ + Qt-RSA/qrsaencryption.h + +SOURCES += \ + Qt-RSA/qrsaencryption.cpp + +target.path = $$GLOBAL_TARGET_PATH/lib +!isEmpty(target.path): INSTALLS += target diff --git a/Qt-Secret/src/build/debug/libQt-Secret.so b/Qt-Secret/src/build/debug/libQt-Secret.so new file mode 120000 index 0000000..12e65b5 --- /dev/null +++ b/Qt-Secret/src/build/debug/libQt-Secret.so @@ -0,0 +1 @@ +libQt-Secret.so.1.2.0 \ No newline at end of file diff --git a/Qt-Secret/src/build/debug/libQt-Secret.so.1 b/Qt-Secret/src/build/debug/libQt-Secret.so.1 new file mode 120000 index 0000000..12e65b5 --- /dev/null +++ b/Qt-Secret/src/build/debug/libQt-Secret.so.1 @@ -0,0 +1 @@ +libQt-Secret.so.1.2.0 \ No newline at end of file diff --git a/Qt-Secret/src/build/debug/libQt-Secret.so.1.2 b/Qt-Secret/src/build/debug/libQt-Secret.so.1.2 new file mode 120000 index 0000000..12e65b5 --- /dev/null +++ b/Qt-Secret/src/build/debug/libQt-Secret.so.1.2 @@ -0,0 +1 @@ +libQt-Secret.so.1.2.0 \ No newline at end of file diff --git a/Qt-Secret/src/build/debug/libQt-Secret.so.1.2.0 b/Qt-Secret/src/build/debug/libQt-Secret.so.1.2.0 new file mode 100755 index 0000000000000000000000000000000000000000..5cc75650d45a825a3c0bacff7e270bb99a4d8338 GIT binary patch literal 595704 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
  • 4joQVE)eHYO+g{AKlRi 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 z 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 + +#if defined(Qt_SECRET_LIBRARY) +# define Qt_SECRETSHARED_EXPORT Q_DECL_EXPORT +#else +# define Qt_SECRETSHARED_EXPORT Q_DECL_IMPORT +#endif + +#endif // QTSECRET_GLOBAL_H