Split headers/code

num_openssl.cpp

@@ -0,0 +1,179 @@
+#include <assert.h>
+#include <string>
+#include <string.h>
+#include <openssl/bn.h>
+#include <openssl/crypto.h>
+
+#include "num_openssl.h"
+
+namespace secp256k1 {
+
+class Context {
+private:
+    BN_CTX *ctx;
+
+    operator BN_CTX*() {
+        return ctx;
+    }
+
+    friend class Number;
+public:
+    Context() {
+        ctx = BN_CTX_new();
+    }
+
+    ~Context() {
+        BN_CTX_free(ctx);
+    }
+};
+
+Number::operator const BIGNUM*() const {
+    return &b;
+}
+
+Number::operator BIGNUM*() {
+    return &b;
+}
+
+Number::Number() {
+    BN_init(*this);
+}
+
+Number::~Number() {
+    BN_free(*this);
+}
+
+Number::Number(const unsigned char *bin, int len) {
+    BN_init(*this);
+    SetBytes(bin,len);
+}
+
+void Number::SetNumber(const Number &x) {
+    BN_copy(*this, x);
+}
+
+Number::Number(const Number &x) {
+    BN_init(*this);
+    BN_copy(*this, x);
+}
+
+Number &Number::operator=(const Number &x) {
+    BN_copy(*this, x);
+    return *this;
+}
+
+void Number::SetBytes(const unsigned char *bin, int len) {
+    BN_bin2bn(bin, len, *this);
+}
+
+void Number::GetBytes(unsigned char *bin, int len) {
+    int size = BN_num_bytes(*this);
+    assert(size <= len);
+    memset(bin,0,len);
+    BN_bn2bin(*this, bin + len - size);
+}
+
+void Number::SetInt(int x) {
+    if (x >= 0) {
+        BN_set_word(*this, x);
+    } else {
+        BN_set_word(*this, -x);
+        BN_set_negative(*this, 1);
+    }
+}
+
+void Number::SetModInverse(const Number &x, const Number &m) {
+    Context ctx;
+    BN_mod_inverse(*this, x, m, ctx);
+}
+
+void Number::SetModMul(const Number &a, const Number &b, const Number &m) {
+    Context ctx;
+    BN_mod_mul(*this, a, b, m, ctx);
+}
+
+void Number::SetAdd(const Number &a1, const Number &a2) {
+    BN_add(*this, a1, a2);
+}
+
+void Number::SetSub(const Number &a1, const Number &a2) {
+    BN_sub(*this, a1, a2);
+}
+
+void Number::SetMult(const Number &a1, const Number &a2) {
+    Context ctx;
+    BN_mul(*this, a1, a2, ctx);
+}
+
+void Number::SetDiv(const Number &a1, const Number &a2) {
+    Context ctx;
+    BN_div(*this, NULL, a1, a2, ctx);
+}
+
+void Number::SetMod(const Number &a, const Number &m) {
+    Context ctx;
+    BN_nnmod(*this, a, m, ctx);
+}
+
+int Number::Compare(const Number &a) const {
+    return BN_cmp(*this, a);
+}
+
+int Number::GetBits() const {
+    return BN_num_bits(*this);
+}
+
+int Number::ShiftLowBits(int bits) {
+    BIGNUM *bn = *this;
+    int ret = BN_is_zero(bn) ? 0 : bn->d[0] & ((1 << bits) - 1);
+    BN_rshift(*this, *this, bits);
+    return ret;
+}
+
+bool Number::IsZero() const {
+    return BN_is_zero((const BIGNUM*)*this);
+}
+
+bool Number::IsOdd() const {
+    return BN_is_odd((const BIGNUM*)*this);
+}
+
+bool Number::IsNeg() const {
+    return BN_is_negative((const BIGNUM*)*this);
+}
+
+void Number::Negate() {
+    BN_set_negative(*this, !IsNeg());
+}
+
+void Number::Shift1() {
+    BN_rshift1(*this,*this);
+}
+
+void Number::Inc() {
+    BN_add_word(*this,1);
+}
+
+void Number::SetHex(const std::string &str) {
+    BIGNUM *bn = *this;
+    BN_hex2bn(&bn, str.c_str());
+}
+
+void Number::SetPseudoRand(const Number &max) {
+    BN_pseudo_rand_range(*this, max);
+}
+
+void Number::SplitInto(int bits, Number &low, Number &high) const {
+    BN_copy(low, *this);
+    BN_mask_bits(low, bits);
+    BN_rshift(high, *this, bits);
+}
+
+std::string Number::ToString() const {
+    char *str = BN_bn2hex(*this);
+    std::string ret(str);
+    OPENSSL_free(str);
+    return ret;
+}
+
+}