класс OpenSSL::BN

Родитель:: Объект
Включенные модули:: Comparable

Константы

CONSTTIME
MALLOCED
STATIC_DATA

Публичные методы класса

generate_prime(bits, [, safe [, add [, rem]]]) → bn Показать исходный код

static VALUE
ossl_bn_s_generate_prime(int argc, VALUE *argv, VALUE klass)
{
    BIGNUM *add = NULL, *rem = NULL, *result;
    int safe = 1, num;
    VALUE vnum, vsafe, vadd, vrem, obj;

    rb_scan_args(argc, argv, "13", &vnum, &vsafe, &vadd, &vrem);

    num = NUM2INT(vnum);

    if (vsafe == Qfalse) {
        safe = 0;
    }
    if (!NIL_P(vadd)) {
        add = GetBNPtr(vadd);
        rem = NIL_P(vrem) ? NULL : GetBNPtr(vrem);
    }
    obj = NewBN(klass);
    if (!(result = BN_new())) {
        ossl_raise(eBNError, NULL);
    }
    if (!BN_generate_prime_ex(result, num, safe, add, rem, NULL)) {
        BN_free(result);
        ossl_raise(eBNError, NULL);
    }
    SetBN(obj, result);

    return obj;
}

Генерирует случайное простое число длиной bits бит. Если safe установлено в true, генерирует безопасное простое число. Если задано add, генерирует простое число, удовлетворяющее условию p % add = rem.

Параметры

bits - целое число
safe - булево значение
add - BN
rem - BN

OpenSSL::BN.new(bn) → aBN Показать исходный код

OpenSSL::BN.new(integer) → aBN

OpenSSL::BN.new(string, base = 10) → aBN

static VALUE
ossl_bn_initialize(int argc, VALUE *argv, VALUE self)
{
    BIGNUM *bn;
    VALUE str, bs;
    int base = 10;
    char *ptr;

    if (rb_scan_args(argc, argv, "11", &str, &bs) == 2) {
        base = NUM2INT(bs);
    }

    if (NIL_P(str)) {
        ossl_raise(rb_eArgError, "invalid argument");
    }

    if (RB_INTEGER_TYPE_P(str)) {
        GetBN(self, bn);
        integer_to_bnptr(str, bn);

        return self;
    }

    if (RTEST(rb_obj_is_kind_of(str, cBN))) {
        BIGNUM *other;

        GetBN(self, bn);
        GetBN(str, other); /* Safe - we checked kind_of? above */
        if (!BN_copy(bn, other)) {
            ossl_raise(eBNError, NULL);
        }
        return self;
    }

    GetBN(self, bn);
    switch (base) {
    case 0:
        ptr = StringValuePtr(str);
        if (!BN_mpi2bn((unsigned char *)ptr, RSTRING_LENINT(str), bn)) {
            ossl_raise(eBNError, NULL);
        }
        break;
    case 2:
        ptr = StringValuePtr(str);
        if (!BN_bin2bn((unsigned char *)ptr, RSTRING_LENINT(str), bn)) {
            ossl_raise(eBNError, NULL);
        }
        break;
    case 10:
        if (!BN_dec2bn(&bn, StringValueCStr(str))) {
            ossl_raise(eBNError, NULL);
        }
        break;
    case 16:
        if (!BN_hex2bn(&bn, StringValueCStr(str))) {
            ossl_raise(eBNError, NULL);
        }
        break;
    default:
        ossl_raise(rb_eArgError, "invalid radix %d", base);
    }
    return self;
}

Создаёт новый объект OpenSSL BIGNUM.

Если bn является Integer или OpenSSL::BN, возвращается новый экземпляр OpenSSL::BN, представляющий ту же самую величину. См. также Integer#to_bn для сокращённой записи.

Если задана String, содержимое будет обработано в соответствии с base.

string

Строка, подлежащая обработке.

base

Формат. Должен быть одним из следующих:

0 - формат MPI. Подробнее см. в руководстве BN_mpi2bn(3).
2 - двоичное кодирование переменной длины и большого порядка для положительного числа.
10 - десятичное представление числа с ведущим ‘-’ для отрицательного числа.
16 - шестнадцатеричное представление числа с ведущим ‘-’ для отрицательного числа.

rand(bits [, fill [, odd]]) → aBN Показать исходный код

static VALUE
ossl_bn_s_rand(int argc, VALUE *argv, VALUE klass)
{
    BIGNUM *result;
    int bottom = 0, top = 0, b;
    VALUE bits, fill, odd, obj;

    switch (rb_scan_args(argc, argv, "12", &bits, &fill, &odd)) {
      case 3:
        bottom = (odd == Qtrue) ? 1 : 0;
        /* FALLTHROUGH */
      case 2:
        top = NUM2INT(fill);
    }
    b = NUM2INT(bits);
    obj = NewBN(klass);
    if (!(result = BN_new())) {
        ossl_raise(eBNError, "BN_new");
    }
    if (BN_rand(result, b, top, bottom) <= 0) {
        BN_free(result);
        ossl_raise(eBNError, "BN_rand");
    }
    SetBN(obj, result);
    return obj;
}

Генерирует криптографически сильное псевдослучайное число длиной bits бит.

См. также страницу руководства BN_rand(3).

rand_range(range) → aBN Показать исходный код

static VALUE
ossl_bn_s_rand_range(VALUE klass, VALUE range)
{
    BIGNUM *bn = GetBNPtr(range), *result;
    VALUE obj = NewBN(klass);
    if (!(result = BN_new()))
        ossl_raise(eBNError, "BN_new");
    if (BN_rand_range(result, bn) <= 0) {
        BN_free(result);
        ossl_raise(eBNError, "BN_rand_range");
    }
    SetBN(obj, result);
    return obj;
}

Генерирует криптографически сильное псевдослучайное число в диапазоне от 0 до range.

См. также страницу руководства BN_rand_range(3).

Общедоступные методы экземпляров

bn % bn2 → aBN

bn * bn2 → aBN

bn ** bn2 → aBN

bn + bn2 → aBN

+bn → aBN Показать исходный код

static VALUE
ossl_bn_uplus(VALUE self)
{
    VALUE obj;
    BIGNUM *bn1, *bn2;

    GetBN(self, bn1);
    obj = NewBN(cBN);
    bn2 = BN_dup(bn1);
    if (!bn2)
        ossl_raise(eBNError, "BN_dup");
    SetBN(obj, bn2);

    return obj;
}

bn - bn2 → aBN

-bn → aBN Показать исходный код

static VALUE
ossl_bn_uminus(VALUE self)
{
    VALUE obj;
    BIGNUM *bn1, *bn2;

    GetBN(self, bn1);
    obj = NewBN(cBN);
    bn2 = BN_dup(bn1);
    if (!bn2)
        ossl_raise(eBNError, "BN_dup");
    SetBN(obj, bn2);
    BN_set_negative(bn2, !BN_is_negative(bn2));

    return obj;
}

bn1 / bn2 → [результат, остаток] Показать исходный код

static VALUE
ossl_bn_div(VALUE self, VALUE other)
{
    BIGNUM *bn1, *bn2 = GetBNPtr(other), *r1, *r2;
    VALUE klass, obj1, obj2;

    GetBN(self, bn1);

    klass = rb_obj_class(self);
    obj1 = NewBN(klass);
    obj2 = NewBN(klass);
    if (!(r1 = BN_new())) {
        ossl_raise(eBNError, NULL);
    }
    if (!(r2 = BN_new())) {
        BN_free(r1);
        ossl_raise(eBNError, NULL);
    }
    if (!BN_div(r1, r2, bn1, bn2, ossl_bn_ctx)) {
        BN_free(r1);
        BN_free(r2);
        ossl_raise(eBNError, NULL);
    }
    SetBN(obj1, r1);
    SetBN(obj2, r2);

    return rb_ary_new3(2, obj1, obj2);
}

Деление экземпляров OpenSSL::BN

bn << bits → aBN

<=>(p1)

Псевдоним для: cmp

bn == obj → true или false Показать исходный код

static VALUE
ossl_bn_eq(VALUE self, VALUE other)
{
    BIGNUM *bn1, *bn2;

    GetBN(self, bn1);
    other = try_convert_to_bn(other);
    if (NIL_P(other))
        return Qfalse;
    GetBN(other, bn2);

    if (!BN_cmp(bn1, bn2)) {
        return Qtrue;
    }
    return Qfalse;
}

Возвращает true только в том случае, если obj имеет то же значение, что и bn. Сравните с OpenSSL::BN#eql?, которое требует, чтобы obj был OpenSSL::BN.

Также псевдоним: ===

===(p1)

Псевдоним для: ==

bn >> bits → aBN

abs → aBN Показать исходный код

static VALUE
ossl_bn_abs(VALUE self)
{
    BIGNUM *bn1;

    GetBN(self, bn1);
    if (BN_is_negative(bn1)) {
        return ossl_bn_uminus(self);
    }
    else {
        return ossl_bn_uplus(self);
    }
}

bit_set?(bit) → true | false Показать исходный код

static VALUE
ossl_bn_is_bit_set(VALUE self, VALUE bit)
{
    int b;
    BIGNUM *bn;

    b = NUM2INT(bit);
    GetBN(self, bn);
    if (BN_is_bit_set(bn, b)) {
        return Qtrue;
    }
    return Qfalse;
}

Проверяет бит bit в bn и возвращает true, если он установлен, и false, если нет.

clear_bit!(bit) → self

cmp(bn2) → целое число

Также псевдоним: <=>

coerce(p1) Показать исходный код

static VALUE
ossl_bn_coerce(VALUE self, VALUE other)
{
    switch(TYPE(other)) {
    case T_STRING:
        self = ossl_bn_to_s(0, NULL, self);
        break;
    case T_FIXNUM:
    case T_BIGNUM:
        self = ossl_bn_to_i(self);
        break;
    default:
        if (!RTEST(rb_obj_is_kind_of(other, cBN))) {
            ossl_raise(rb_eTypeError, "Don't know how to coerce");
        }
    }
    return rb_assoc_new(other, self);
}

copy(p1)

Псевдоним для: initialize_copy

eql?(obj) → true или false Показать исходный код

static VALUE
ossl_bn_eql(VALUE self, VALUE other)
{
    BIGNUM *bn1, *bn2;

    if (!rb_obj_is_kind_of(other, cBN))
        return Qfalse;
    GetBN(self, bn1);
    GetBN(other, bn2);

    return BN_cmp(bn1, bn2) ? Qfalse : Qtrue;
}

Возвращает true только в том случае, если obj является OpenSSL::BN с тем же значением, что и bn. Сравните с OpenSSL::BN#==, которая выполняет преобразования типов.

gcd(bn2) → aBN

get_flags(flags) → flags Показать исходный код

static VALUE
ossl_bn_get_flags(VALUE self, VALUE arg)
{
    BIGNUM *bn;
    GetBN(self, bn);

    return INT2NUM(BN_get_flags(bn, NUM2INT(arg)));
}

Возвращает флаги объекта BN. Аргумент используется в качестве битовой маски.

Параметры

flags - целое число

hash → Целое число Показать исходный код

static VALUE
ossl_bn_hash(VALUE self)
{
    BIGNUM *bn;
    VALUE tmp, hash;
    unsigned char *buf;
    int len;

    GetBN(self, bn);
    len = BN_num_bytes(bn);
    buf = ALLOCV(tmp, len);
    if (BN_bn2bin(bn, buf) != len) {
        ALLOCV_END(tmp);
        ossl_raise(eBNError, "BN_bn2bin");
    }

    hash = ST2FIX(rb_memhash(buf, len));
    ALLOCV_END(tmp);

    return hash;
}

Возвращает хэш-код для данного объекта.

См. также Object#hash.

initialize_copy(p1) Показать исходный код

static VALUE
ossl_bn_copy(VALUE self, VALUE other)
{
    BIGNUM *bn1, *bn2;

    rb_check_frozen(self);

    if (self == other) return self;

    GetBN(self, bn1);
    bn2 = GetBNPtr(other);

    if (!BN_copy(bn1, bn2)) {
        ossl_raise(eBNError, NULL);
    }
    return self;
}

Также псевдоним: copy

lshift!(bits) → self

mod_add(bn1, bn2) → aBN

mod_exp(bn1, bn2) → aBN

mod_inverse(bn2) → aBN Показать исходный код

static VALUE
ossl_bn_mod_inverse(VALUE self, VALUE other)
{
    BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;
    VALUE obj;
    GetBN(self, bn1);
    obj = NewBN(rb_obj_class(self));
    if (!(result = BN_mod_inverse(NULL, bn1, bn2, ossl_bn_ctx)))
        ossl_raise(eBNError, "BN_mod_inverse");
    SetBN(obj, result);
    return obj;
}

mod_mul(bn1, bn2) → aBN

mod_sqr(bn2) → aBN

mod_sub(bn1, bn2) → aBN

negative? → true | false Показать исходный код

static VALUE
ossl_bn_is_negative(VALUE self)
{
    BIGNUM *bn;

    GetBN(self, bn);
    if (BN_is_zero(bn))
        return Qfalse;
    return BN_is_negative(bn) ? Qtrue : Qfalse;
}

num_bits → целое число

num_bytes → целое число

odd? → true | false

one? → true | false

pretty_print(q) Показать исходный код

# File ext/openssl/lib/openssl/bn.rb, line 20
def pretty_print(q)
  q.object_group(self) {
    q.text ' '
    q.text to_i.to_s
  }
end

prime? → true | false Показать исходный код

prime?(checks) → true | false

static VALUE
ossl_bn_is_prime(int argc, VALUE *argv, VALUE self)
{
    BIGNUM *bn;
    int ret;

    rb_check_arity(argc, 0, 1);
    GetBN(self, bn);

#ifdef HAVE_BN_CHECK_PRIME
    ret = BN_check_prime(bn, ossl_bn_ctx, NULL);
    if (ret < 0)
        ossl_raise(eBNError, "BN_check_prime");
#else
    ret = BN_is_prime_fasttest_ex(bn, BN_prime_checks, ossl_bn_ctx, 1, NULL);
    if (ret < 0)
        ossl_raise(eBNError, "BN_is_prime_fasttest_ex");
#endif
    return ret ? Qtrue : Qfalse;
}

Выполняет вероятностный тест простоты Миллера-Рабина для bn.

Параметр checks устарел в версии 3.0. Он не имеет эффекта.

prime_fasttest? → true | false Показать исходный код

prime_fasttest?(checks) → true | false

prime_fasttest?(checks, trial_div) → true | false

static VALUE
ossl_bn_is_prime_fasttest(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 0, 2);
    return ossl_bn_is_prime(0, argv, self);
}

Выполняет вероятностный тест простоты Миллера-Рабина для bn.

Устарело в версии 3.0. Используйте prime? вместо этого.

Параметры checks и trial_div больше не имеют эффекта.

rshift!(bits) → self

END_OF_DOCUMENT_MARKER

set_bit!(bit) → self

set_flags(flags) → nil Показать исходный код

static VALUE
ossl_bn_set_flags(VALUE self, VALUE arg)
{
    BIGNUM *bn;
    GetBN(self, bn);

    BN_set_flags(bn, NUM2INT(arg));
    return Qnil;
}

Включает флаги в объекте BN. В настоящее время аргумент flags может содержать ноль OpenSSL::BN::CONSTTIME.

sqr → aBN

to_bn() Показать исходный код

static VALUE
ossl_bn_to_bn(VALUE self)
{
    return self;
}

to_i → целое Показать исходный код

static VALUE
ossl_bn_to_i(VALUE self)
{
    BIGNUM *bn;
    char *txt;
    VALUE num;

    GetBN(self, bn);

    if (!(txt = BN_bn2hex(bn))) {
        ossl_raise(eBNError, NULL);
    }
    num = rb_cstr_to_inum(txt, 16, Qtrue);
    OPENSSL_free(txt);

    return num;
}

Также алиас: to_int

to_int()

Псевдоним для: to_i

to_s(base = 10) → строка Показать исходный код

static VALUE
ossl_bn_to_s(int argc, VALUE *argv, VALUE self)
{
    BIGNUM *bn;
    VALUE str, bs;
    int base = 10, len;
    char *buf;

    if (rb_scan_args(argc, argv, "01", &bs) == 1) {
        base = NUM2INT(bs);
    }
    GetBN(self, bn);
    switch (base) {
    case 0:
        len = BN_bn2mpi(bn, NULL);
        str = rb_str_new(0, len);
        if (BN_bn2mpi(bn, (unsigned char *)RSTRING_PTR(str)) != len)
            ossl_raise(eBNError, NULL);
        break;
    case 2:
        len = BN_num_bytes(bn);
        str = rb_str_new(0, len);
        if (BN_bn2bin(bn, (unsigned char *)RSTRING_PTR(str)) != len)
            ossl_raise(eBNError, NULL);
        break;
    case 10:
        if (!(buf = BN_bn2dec(bn))) ossl_raise(eBNError, NULL);
        str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
        break;
    case 16:
        if (!(buf = BN_bn2hex(bn))) ossl_raise(eBNError, NULL);
        str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
        break;
    default:
        ossl_raise(rb_eArgError, "invalid radix %d", base);
    }

    return str;
}

Возвращает строковое представление числа bignum.

BN.new может проанализировать закодированную строку, чтобы преобразовать её обратно в OpenSSL::BN.

base

Формат. Должен быть одним из следующих:

0 - Формат MPI. Подробности см. в руководстве BN_bn2mpi(3).
2 - Многобайтовое и big-endian двоичное кодирование. Знак числа bignum игнорируется.
10 - Десятичное представление числа, с ведущим ‘-’ для отрицательного bignum.
16 - Шестнадцатеричное представление числа, с ведущим ‘-’ для отрицательного bignum.

ucmp(bn2) → целое

zero? → true | false

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.