big-ssl.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2010 pancake <pancake@nopcode.org>
// SPDX-FileCopyrightText: 2020 FXTi <zjxiang1998@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_util.h>
 
RZ_API RzNumBig *rz_big_new(void) {
    return BN_new();
}
 
RZ_API void rz_big_free(RzNumBig *b) {
    BN_free(b);
}
 
RZ_API void rz_big_init(RzNumBig *b) {
    BN_zero(b);
}
 
RZ_API void rz_big_fini(RzNumBig *b) {
    BN_clear(b);
}
 
RZ_API void rz_big_from_int(RzNumBig *b, st64 v) {
    if (v < 0) {
        BN_set_word(b, -v);
        BN_set_negative(b, v);
    } else {
        BN_set_word(b, v);
    }
}
 
RZ_API st64 rz_big_to_int(RzNumBig *b) {
    BN_ULONG maxx = 0;
    maxx = ~maxx;
    BN_ULONG res = BN_get_word(b);
    if (res == maxx) {
        RzNumBig *B = rz_big_new();
        rz_big_assign(B, b);
        BN_mask_bits(B, BN_BYTES * 8 - 1);
        res = BN_get_word(B);
        rz_big_free(B);
    }
    res *= (BN_is_negative(b) ? -1 : 1);
    return res;
}
 
RZ_API void rz_big_from_hexstr(RzNumBig *b, const char *str) {
    if (rz_str_startswith(str, "0x")) {
        str += 2;
        BN_hex2bn(&b, str);
    } else if (rz_str_startswith(str, "-0x")) {
        str += 3;
        BN_hex2bn(&b, str);
        BN_set_negative(b, -1);
    }
}
 
RZ_API char *rz_big_to_hexstr(RzNumBig *b) {
    char *tmp = BN_bn2hex(b);
    char *res;
    if (tmp[0] == '-') {
        res = rz_str_newf("-0x%s", &tmp[1]);
    } else {
        res = rz_str_newf("0x%s", tmp);
    }
    OPENSSL_free(tmp);
    for (size_t i = 0; res[i]; i++) {
        res[i] = tolower(res[i]);
    }
    return res;
}
 
RZ_API void rz_big_assign(RzNumBig *dst, RzNumBig *src) {
    BN_copy(dst, src);
}
 
RZ_API void rz_big_add(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    BN_add(c, a, b);
}
 
RZ_API void rz_big_sub(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    BN_sub(c, a, b);
}
 
RZ_API void rz_big_mul(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    BN_CTX *bn_ctx = BN_CTX_new();
    BN_mul(c, a, b, bn_ctx);
    BN_CTX_free(bn_ctx);
}
 
RZ_API void rz_big_div(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    BN_CTX *bn_ctx = BN_CTX_new();
    BN_div(c, NULL, a, b, bn_ctx);
    BN_CTX_free(bn_ctx);
}
 
RZ_API void rz_big_mod(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    BN_CTX *bn_ctx = BN_CTX_new();
    BN_mod(c, a, b, bn_ctx);
    BN_CTX_free(bn_ctx);
}
 
RZ_API void rz_big_divmod(RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b) {
    BN_CTX *bn_ctx = BN_CTX_new();
    BN_div(c, d, a, b, bn_ctx);
    BN_CTX_free(bn_ctx);
}
 
RZ_API void rz_big_and(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    RzNumBig *A = rz_big_new();
    RzNumBig *B = rz_big_new();
    RzNumBig *C = rz_big_new();
    RzNumBig *addition = rz_big_new();
 
    size_t step = 4 * 8, move = 0;
    ut32 tmp = 0;
    rz_big_assign(A, a);
    rz_big_assign(B, b);
 
    while (!rz_big_is_zero(A) || !rz_big_is_zero(B)) {
        tmp = rz_big_to_int(A);
        tmp &= rz_big_to_int(B);
        rz_big_rshift(A, A, step);
        rz_big_rshift(B, B, step);
        rz_big_from_int(addition, tmp);
        rz_big_lshift(addition, addition, move);
        rz_big_add(C, C, addition);
 
        move += step;
    }
 
    rz_big_assign(c, C);
 
    rz_big_free(A);
    rz_big_free(B);
    rz_big_free(C);
    rz_big_free(addition);
}
 
RZ_API void rz_big_or(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    RzNumBig *A = rz_big_new();
    RzNumBig *B = rz_big_new();
    RzNumBig *C = rz_big_new();
    RzNumBig *addition = rz_big_new();
 
    size_t step = 4 * 8, move = 0;
    ut32 tmp = 0;
    rz_big_assign(A, a);
    rz_big_assign(B, b);
 
    while (!rz_big_is_zero(A) || !rz_big_is_zero(B)) {
        tmp = rz_big_to_int(A);
        tmp |= rz_big_to_int(B);
        rz_big_rshift(A, A, step);
        rz_big_rshift(B, B, step);
        rz_big_from_int(addition, tmp);
        rz_big_lshift(addition, addition, move);
        rz_big_add(C, C, addition);
 
        move += step;
    }
 
    rz_big_assign(c, C);
 
    rz_big_free(A);
    rz_big_free(B);
    rz_big_free(C);
    rz_big_free(addition);
}
 
RZ_API void rz_big_xor(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
    RzNumBig *A = rz_big_new();
    RzNumBig *B = rz_big_new();
    RzNumBig *C = rz_big_new();
    RzNumBig *addition = rz_big_new();
 
    size_t step = 4 * 8, move = 0;
    ut32 tmp = 0;
    rz_big_assign(A, a);
    rz_big_assign(B, b);
 
    while (!rz_big_is_zero(A) || !rz_big_is_zero(B)) {
        tmp = rz_big_to_int(A);
        tmp ^= rz_big_to_int(B);
        rz_big_rshift(A, A, step);
        rz_big_rshift(B, B, step);
        rz_big_from_int(addition, tmp);
        rz_big_lshift(addition, addition, move);
        rz_big_add(C, C, addition);
 
        move += step;
    }
 
    rz_big_assign(c, C);
 
    rz_big_free(A);
    rz_big_free(B);
    rz_big_free(C);
    rz_big_free(addition);
}
 
RZ_API void rz_big_lshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
    BN_lshift(c, a, nbits);
}
 
RZ_API void rz_big_rshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
    BN_rshift(c, a, nbits);
}
 
RZ_API int rz_big_cmp(RzNumBig *a, RzNumBig *b) {
    return BN_cmp(a, b);
}
 
RZ_API int rz_big_is_zero(RzNumBig *a) {
    return BN_is_zero(a);
}
 
RZ_API void rz_big_inc(RzNumBig *a) {
    BN_add_word(a, 1);
}
 
RZ_API void rz_big_dec(RzNumBig *a) {
    BN_sub_word(a, 1);
}
 
RZ_API void rz_big_powm(RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m) {
    BN_CTX *bn_ctx = BN_CTX_new();
    BN_mod_exp(c, a, b, m, bn_ctx);
    BN_CTX_free(bn_ctx);
}
 
RZ_API void rz_big_isqrt(RzNumBig *b, RzNumBig *a) {
    RzNumBig *tmp = rz_big_new();
    RzNumBig *low = rz_big_new();
    RzNumBig *high = rz_big_new();
    RzNumBig *mid = rz_big_new();
 
    rz_big_assign(high, a);
    rz_big_rshift(mid, high, 1);
    rz_big_inc(mid);
 
    while (rz_big_cmp(high, low) > 0) {
        rz_big_mul(tmp, mid, mid);
        if (rz_big_cmp(tmp, a) > 0) {
            rz_big_assign(high, mid);
            rz_big_dec(high);
        } else {
            rz_big_assign(low, mid);
        }
        rz_big_sub(mid, high, low);
        rz_big_rshift(mid, mid, 1);
        rz_big_add(mid, mid, low);
        rz_big_inc(mid);
    }
    rz_big_assign(b, low);
 
    rz_big_free(tmp);
    rz_big_free(low);
    rz_big_free(high);
    rz_big_free(mid);
}