class OpenSSL::BN - Documentation for Ruby 2.3.0 (original) (raw)

Public Class Methods

generate_prime(bits, [, safe [, add [, rem]]]) → bn click to toggle source

Parameters¶ ↑

• bits - integer
• safe - boolean
• add - BN
• 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(result, num, safe, add, rem, NULL, NULL)) {
    BN_free(result);
    ossl_raise(eBNError, NULL);
}
SetBN(obj, result);

return obj;

}

new(p1, p2 = v2) click to toggle source

OpenSSL::BN.new => aBN OpenSSL::BN.new(bn) => aBN OpenSSL::BN.new(integer) => aBN OpenSSL::BN.new(string) => aBN OpenSSL::BN.new(string, 0 | 2 | 10 | 16) => aBN

Construct a new OpenSSL BigNum object.

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

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

if (RB_TYPE_P(str, T_FIXNUM)) {
    long i;
    unsigned char bin[sizeof(long)];
    long n = FIX2LONG(str);
    unsigned long un = labs(n);

    for (i = sizeof(long) - 1; 0 <= i; i--) {
        bin[i] = un&0xff;
        un >>= 8;
    }

    GetBN(self, bn);
    if (!BN_bin2bn(bin, sizeof(bin), bn)) {
        ossl_raise(eBNError, NULL);
    }
    if (n < 0) BN_set_negative(bn, 1);
    return self;
}
else if (RB_TYPE_P(str, T_BIGNUM)) {
    size_t len = rb_absint_size(str, NULL);
    unsigned char *bin;
    VALUE buf;
    int sign;

    if (INT_MAX < len) {
        rb_raise(eBNError, "bignum too long");
    }
    bin = (unsigned char*)ALLOCV_N(unsigned char, buf, len);
    sign = rb_integer_pack(str, bin, len, 1, 0, INTEGER_PACK_BIG_ENDIAN);

    GetBN(self, bn);
    if (!BN_bin2bn(bin, (int)len, bn)) {
        ALLOCV_END(buf);
        ossl_raise(eBNError, NULL);
    }
    ALLOCV_END(buf);
    if (sign < 0) BN_set_negative(bn, 1);
    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;
}

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

}

Public Instance Methods

/(p1) click to toggle source

bn1 / bn2 => [result, remainder]

Division of OpenSSL::BN instances

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

GetBN(self, bn1);

obj1 = NewBN(CLASS_OF(self));
obj2 = NewBN(CLASS_OF(self));
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);

}

bn == obj → true or false click to toggle source

Returns true only if obj has the same value as bn. Contrast this with OpenSSL::BN#eql?, which requires obj to be OpenSSL::BN.

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

GetBN(self, bn1);
/* BNPtr may raise, so we can't use here */
bn2 = try_convert_to_bnptr(other);

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

}

Also aliased as: ===

bit_set?(p1) click to toggle source

Returns boolean of whether bit is set. Bitwise operations for openssl BIGNUMs.

bn.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;

}

clear_bit!(p1)

bn.clear_bit!(bit) -> self

cmp(p1)

bn.cmp(bn2) => integer

Also aliased as: <=>

coerce(p1) click to toggle source

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) click to toggle source

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;

}

eql?(obj) → true or false click to toggle source

Returns true only if obj is a OpenSSL::BN with the same value as big. Contrast this with OpenSSL::BN#==, which performs type conversions.

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;

}

gcd(p1)

bn.gcd(bn2) => aBN

hash → Integer click to toggle source

Returns a hash code for this object.

See also Object#hash.

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

GetBN(self, bn);
len = BN_num_bytes(bn);
buf = xmalloc(len);
if (BN_bn2bin(bn, buf) != len) {
    xfree(buf);
    ossl_raise(eBNError, NULL);
}

hash = LONG2FIX((long)rb_memhash(buf, len));
xfree(buf);

return hash;

}

lshift!(p1)

bn.lshift!(bits) -> self

mod_add(p1, p2)

bn.mod_add(bn1, bn2) -> aBN

mod_exp(p1, p2)

bn.mod_exp(bn1, bn2) -> aBN

mod_inverse(p1)

bn.mod_inverse(bn2) => aBN

mod_mul(p1, p2)

bn.mod_mul(bn1, bn2) -> aBN

mod_sqr(p1)

bn.mod_sqr(bn2) => aBN

mod_sub(p1, p2)

bn.mod_sub(bn1, bn2) -> aBN

num_bits()

bn.num_bits => integer

num_bytes()

bn.num_bytes => integer

odd?()

bn.odd? => true | false

one?()

bn.one? => true | false

pretty_print(q) click to toggle source

def pretty_print(q) q.object_group(self) { q.text ' ' q.text to_i.to_s } end

prime? → true | false click to toggle source

prime?(checks) → true | false

Parameters¶ ↑

• checks - integer

static VALUE ossl_bn_is_prime(int argc, VALUE *argv, VALUE self) { BIGNUM *bn; VALUE vchecks; int checks = BN_prime_checks;

if (rb_scan_args(argc, argv, "01", &vchecks) == 1) {
    checks = NUM2INT(vchecks);
}
GetBN(self, bn);
switch (BN_is_prime(bn, checks, NULL, ossl_bn_ctx, NULL)) {
case 1:
    return Qtrue;
case 0:
    return Qfalse;
default:
    ossl_raise(eBNError, NULL);
}
/* not reachable */
return Qnil;

}

prime_fasttest? → true | false click to toggle source

prime_fasttest?(checks) → true | false

prime_fasttest?(checks, trial_div) → true | false

Parameters¶ ↑

• checks - integer
• trial_div - boolean

static VALUE ossl_bn_is_prime_fasttest(int argc, VALUE *argv, VALUE self) { BIGNUM *bn; VALUE vchecks, vtrivdiv; int checks = BN_prime_checks, do_trial_division = 1;

rb_scan_args(argc, argv, "02", &vchecks, &vtrivdiv);

if (!NIL_P(vchecks)) {
    checks = NUM2INT(vchecks);
}
GetBN(self, bn);
/* handle true/false */
if (vtrivdiv == Qfalse) {
    do_trial_division = 0;
}
switch (BN_is_prime_fasttest(bn, checks, NULL, ossl_bn_ctx, NULL, do_trial_division)) {
case 1:
    return Qtrue;
case 0:
    return Qfalse;
default:
    ossl_raise(eBNError, NULL);
}
/* not reachable */
return Qnil;

}

rshift!(p1)

bn.rshift!(bits) -> self

set_bit!(p1)

bn.set_bit!(bit) -> self

to_bn() click to toggle source

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

to_i → integer click to toggle source

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_s → string click to toggle source

to_s(base) → string

Parameters¶ ↑

• base - integer
• • Valid values:
• • • 0 - MPI
• • • 2 - binary
• • • 10 - the default
• • • 16 - hex

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;

}

ucmp(p1)

bn.ucmp(bn2) => integer

zero?()

bn.zero? => true | false