In Files

  • openssl/lib/openssl/bn.rb
  • openssl/ossl.c

Class/Module Index [+]

Quicksearch

OpenSSL::BN

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

bn % bn2 => aBN

*(p1) click to toggle source

bn * bn2 => aBN

**(p1) click to toggle source

bn ** bn2 => aBN

+(p1) click to toggle source

bn + bn2 => aBN

-(p1) click to toggle source

bn - bn2 => aBN

/(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 << bits → aBN click to toggle source
<=>(p1) click to toggle source
Alias for: cmp
==(p1) click to toggle source
Alias for: eql?
===(p1) click to toggle source
Alias for: eql?
bn >> bits → aBN click to toggle source
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) click to toggle source

bn.clear_bit!(bit) -> self

cmp(p1) click to toggle source

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 Bignum with the same value as big. Contrast this

 
               static VALUE
ossl_bn_eql(VALUE self, VALUE other)
{
    if (ossl_bn_cmp(self, other) == INT2FIX(0)) {
        return Qtrue;
    }
    return Qfalse;
}
            
Also aliased as: ==, ===
gcd(p1) click to toggle source

bn.gcd(bn2) => aBN

lshift!(p1) click to toggle source

bn.lshift!(bits) -> self

mod_add(p1, p2) click to toggle source

bn.mod_add(bn1, bn2) -> aBN

mod_exp(p1, p2) click to toggle source

bn.mod_exp(bn1, bn2) -> aBN

mod_inverse(p1) click to toggle source

bn.mod_inverse(bn2) => aBN

mod_mul(p1, p2) click to toggle source

bn.mod_mul(bn1, bn2) -> aBN

mod_sqr(p1) click to toggle source

bn.mod_sqr(bn2) => aBN

mod_sub(p1, p2) click to toggle source

bn.mod_sub(bn1, bn2) -> aBN

num_bits() click to toggle source

bn.num_bits => integer

num_bytes() click to toggle source

bn.num_bytes => integer

odd?() click to toggle source

bn.odd? => true | false

one?() click to toggle source

bn.one? => true | false

pretty_print(q) click to toggle source
 
               # File 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 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) click to toggle source

bn.rshift!(bits) -> self

set_bit!(p1) click to toggle source

bn.set_bit!(bit) -> self

sqr() click to toggle source

bn.sqr => aBN

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;
}
            
Also aliased as: to_int
to_int() click to toggle source
Alias for: to_i
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) click to toggle source

bn.ucmp(bn2) => integer

zero?() click to toggle source

bn.zero? => true | false