Class: OpenSSL::BN (Ruby 2.4.2)
Description: Class : OpenSSL::BN - Ruby 2.4.2

Support for the Ruby 2.4 series has ended. See here for reference.

### Home Classes Methods

### In Files

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

### Parent

Object

### Methods

- ::generate_prime
- ::new
- #%
- #*
- #**
- #+
- #-
- #/
- #<<
- #<=>
- #==
- #===
- #>>
- #bit_set?
- #clear_bit!
- #cmp
- #coerce
- #copy
- #eql?
- #gcd
- #hash
- #lshift!
- #mod_add
- #mod_exp
- #mod_inverse
- #mod_mul
- #mod_sqr
- #mod_sub
- #num_bits
- #num_bytes
- #odd?
- #one?
- #pretty_print
- #prime?
- #prime_fasttest?
- #rshift!
- #set_bit!
- #sqr
- #to_bn
- #to_i
- #to_int
- #to_s
- #ucmp
- #zero?

### Included Modules

- Comparable

### Class/Module Index

Quicksearch

- IO
- IO::WaitReadable
- IO::WaitWritable
- Integer
- OpenSSL
- OpenSSL::ASN1
- OpenSSL::ASN1::ASN1Data
- OpenSSL::ASN1::ASN1Error
- OpenSSL::ASN1::Constructive
- OpenSSL::ASN1::ObjectId
- OpenSSL::ASN1::Primitive
- OpenSSL::BN
- OpenSSL::BNError
- OpenSSL::Buffering
- OpenSSL::Cipher
- OpenSSL::Cipher::Cipher
- OpenSSL::Cipher::CipherError
- OpenSSL::Config
- OpenSSL::ConfigError
- OpenSSL::Digest
- OpenSSL::Digest::DigestError
- OpenSSL::Engine
- OpenSSL::Engine::EngineError
- OpenSSL::ExtConfig
- OpenSSL::HMAC
- OpenSSL::HMACError
- OpenSSL::Netscape
- OpenSSL::Netscape::SPKI
- OpenSSL::Netscape::SPKIError
- OpenSSL::OCSP
- OpenSSL::OCSP::BasicResponse
- OpenSSL::OCSP::CertificateId
- OpenSSL::OCSP::OCSPError
- OpenSSL::OCSP::Request
- OpenSSL::OCSP::Response
- OpenSSL::OCSP::SingleResponse
- OpenSSL::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- OpenSSL::PKCS5::PKCS5Error
- OpenSSL::PKCS7
- OpenSSL::PKCS7::PKCS7Error
- OpenSSL::PKCS7::RecipientInfo
- OpenSSL::PKCS7::SignerInfo
- OpenSSL::PKey
- OpenSSL::PKey::DH
- OpenSSL::PKey::DHError
- OpenSSL::PKey::DSA
- OpenSSL::PKey::DSAError
- OpenSSL::PKey::EC
- OpenSSL::PKey::EC::Group
- OpenSSL::PKey::EC::Group::Error
- OpenSSL::PKey::EC::Point
- OpenSSL::PKey::EC::Point::Error
- OpenSSL::PKey::ECError
- OpenSSL::PKey::PKey
- OpenSSL::PKey::PKeyError
- OpenSSL::PKey::RSA
- OpenSSL::PKey::RSAError
- OpenSSL::Random
- OpenSSL::Random::RandomError
- OpenSSL::SSL
- OpenSSL::SSL::SSLContext
- OpenSSL::SSL::SSLError
- OpenSSL::SSL::SSLErrorWaitReadable
- OpenSSL::SSL::SSLErrorWaitWritable
- OpenSSL::SSL::SSLServer
- OpenSSL::SSL::SSLSocket
- OpenSSL::SSL::Session
- OpenSSL::SSL::Session::SessionError
- OpenSSL::SSL::SocketForwarder
- OpenSSL::X509
- OpenSSL::X509::Attribute
- OpenSSL::X509::AttributeError
- OpenSSL::X509::CRL
- OpenSSL::X509::CRLError
- OpenSSL::X509::Certificate
- OpenSSL::X509::CertificateError
- OpenSSL::X509::Extension
- OpenSSL::X509::ExtensionError
- OpenSSL::X509::ExtensionFactory
- OpenSSL::X509::Name
- OpenSSL::X509::Name::RFC2253DN
- OpenSSL::X509::NameError
- OpenSSL::X509::Request
- OpenSSL::X509::RequestError
- OpenSSL::X509::Revoked
- OpenSSL::X509::RevokedError
- OpenSSL::X509::Store
- OpenSSL::X509::StoreContext
- OpenSSL::X509::StoreError

No matching classes.

# OpenSSL::BN

### Public Class Methods

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

Generates a random prime number of bit length `bits`. If `safe` is true, generates a safe prime. If `add` is specified, generates a prime that fulfills condition `p % add = rem`.

### 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_ex(result, num, safe, add, rem, NULL)) {
            BN_free(result);
            ossl_raise(eBNError, NULL);
        }
        SetBN(obj, result);

        return obj;
    }

OpenSSL::BN.new => aBN click to toggle source
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_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:
            if (!BN_mpi2bn((unsigned char *)StringValuePtr(str), RSTRING_LENINT(str), bn)) {
                ossl_raise(eBNError, NULL);
            }
            break;
        case 2:
            if (!BN_bin2bn((unsigned char *)StringValuePtr(str), 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;
    }

### Public Instance Methods

bn % bn2 => aBN click to toggle source
bn * bn2 => aBN click to toggle source
bn ** bn2 => aBN click to toggle source
bn + bn2 => aBN click to toggle source
bn - bn2 => aBN click to toggle source
bn1 / bn2 => [result, remainder] click to toggle source

Division of `OpenSSL::BN` instances

                   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);
    }

bn << bits → aBN click to toggle source
<=>(p1) click to toggle source
Alias for: cmp
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);
        other = try_convert_to_bn(other);
        if (NIL_P(other))
            return Qfalse;
        GetBN(other, bn2);

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

Also aliased as: ===
===(p1) click to toggle source
Alias for: ==
bn >> bits → aBN click to toggle source
bit_set?(bit) => true | false click to toggle source

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

                   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!(bit) → self click to toggle source
cmp(bn2) => integer click to toggle source
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(bn2) => aBN click to toggle source
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 = ST2FIX(rb_memhash(buf, len));
        xfree(buf);

        return hash;
    }

lshift!(bits) → self click to toggle source
mod_add(bn1, bn2) → aBN click to toggle source
mod_exp(bn1, bn2) → aBN click to toggle source
mod_inverse(bn2) => aBN click to toggle source
mod_mul(bn1, bn2) → aBN click to toggle source
mod_sqr(bn2) => aBN click to toggle source
mod_sub(bn1, bn2) → aBN click to toggle source
num_bits => integer click to toggle source
num_bytes => integer click to toggle source
odd? => true | false click to toggle source
one? => true | false click to toggle source
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

Performs a Miller-Rabin probabilistic primality test with `checks` iterations. If `nchecks` is not specified, a number of iterations is used that yields a false positive rate of at most 2^-80 for random input.

### 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_ex(bn, checks, 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

Performs a Miller-Rabin primality test. This is same as `prime?` except this first attempts trial divisions with some small primes.

### 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_ex(bn, checks, ossl_bn_ctx, do_trial_division, NULL)) {
        case 1:
            return Qtrue;
        case 0:
            return Qfalse;
        default:
            ossl_raise(eBNError, NULL);
        }
        /* not reachable */
        return Qnil;
    }

rshift!(bits) → self click to toggle source
set_bit!(bit) → self click to toggle source
sqr => aBN click to toggle source
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(bn2) => integer click to toggle source
zero? => true | false click to toggle source