Class: OpenSSL::PKey::EC::Group (Ruby 2.5.7)
Description: Class : OpenSSL::PKey::EC::Group - Ruby 2.5.7

### Home Classes Methods

### In Files

- openssl/ossl_pkey.c

### Parent

Object

### Namespace

- CLASS OpenSSL::PKey::EC::Group::Error

### Methods

- ::new
- #==
- #asn1_flag
- #asn1_flag=
- #cofactor
- #curve_name
- #degree
- #eql?
- #generator
- #initialize_copy
- #order
- #point_conversion_form
- #point_conversion_form=
- #seed
- #seed=
- #set_generator
- #to_der
- #to_pem
- #to_text

### 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::KDF
- OpenSSL::KDF::KDFError
- 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::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::PKey::EC::Group

### Public Class Methods

OpenSSL::PKey::EC::Group.new(ec_group) click to toggle source
OpenSSL::PKey::EC::Group.new(pem_or_der_encoded)
OpenSSL::PKey::EC::Group.new(ec_method)
OpenSSL::PKey::EC::Group.new(:GFp, bignum_p, bignum_a, bignum_b)
OpenSSL::PKey::EC::Group.new(:GF2m, bignum_p, bignum_a, bignum_b)

Creates a new `EC::Group` object.

ec_method is a symbol that represents an EC_METHOD. Currently the following are supported:

- :GFp_simple

- :GFp_mont

- :GFp_nist

- :GF2m_simple

If the first argument is :GFp or :GF2m, creates a new curve with given parameters.

                   static VALUE ossl_ec_group_initialize(int argc, VALUE *argv, VALUE self)
    {
        VALUE arg1, arg2, arg3, arg4;
        EC_GROUP *group;

        TypedData_Get_Struct(self, EC_GROUP, &ossl_ec_group_type, group);
        if (group)
            ossl_raise(rb_eRuntimeError, "EC_GROUP is already initialized");

        switch (rb_scan_args(argc, argv, "13", &arg1, &arg2, &arg3, &arg4)) {
        case 1:
            if (SYMBOL_P(arg1)) {
                const EC_METHOD *method = NULL;
                ID id = SYM2ID(arg1);

                if (id == s_GFp_simple) {
                    method = EC_GFp_simple_method();
                } else if (id == s_GFp_mont) {
                    method = EC_GFp_mont_method();
                } else if (id == s_GFp_nist) {
                    method = EC_GFp_nist_method();
    #if !defined(OPENSSL_NO_EC2M)
                } else if (id == s_GF2m_simple) {
                    method = EC_GF2m_simple_method();
    #endif
                }

                if (method) {
                    if ((group = EC_GROUP_new(method)) == NULL)
                        ossl_raise(eEC_GROUP, "EC_GROUP_new");
                } else {
                    ossl_raise(rb_eArgError, "unknown symbol, must be :GFp_simple, :GFp_mont, :GFp_nist or :GF2m_simple");
                }
            } else if (rb_obj_is_kind_of(arg1, cEC_GROUP)) {
                const EC_GROUP *arg1_group;

                GetECGroup(arg1, arg1_group);
                if ((group = EC_GROUP_dup(arg1_group)) == NULL)
                    ossl_raise(eEC_GROUP, "EC_GROUP_dup");
            } else {
                BIO *in = ossl_obj2bio(&arg1);

                group = PEM_read_bio_ECPKParameters(in, NULL, NULL, NULL);
                if (!group) {
                    OSSL_BIO_reset(in);
                    group = d2i_ECPKParameters_bio(in, NULL);
                }

                BIO_free(in);

                if (!group) {
                    const char *name = StringValueCStr(arg1);
                    int nid = OBJ_sn2nid(name);

                    ossl_clear_error(); /* ignore errors in d2i_ECPKParameters_bio() */
                    if (nid == NID_undef)
                        ossl_raise(eEC_GROUP, "unknown curve name (%"PRIsVALUE")", arg1);

                    group = EC_GROUP_new_by_curve_name(nid);
                    if (group == NULL)
                        ossl_raise(eEC_GROUP, "unable to create curve (%"PRIsVALUE")", arg1);

                    EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
                    EC_GROUP_set_point_conversion_form(group, POINT_CONVERSION_UNCOMPRESSED);
                }
            }

            break;
        case 4:
            if (SYMBOL_P(arg1)) {
                ID id = SYM2ID(arg1);
                EC_GROUP *(*new_curve)(const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *) = NULL;
                const BIGNUM *p = GetBNPtr(arg2);
                const BIGNUM *a = GetBNPtr(arg3);
                const BIGNUM *b = GetBNPtr(arg4);

                if (id == s_GFp) {
                    new_curve = EC_GROUP_new_curve_GFp;
    #if !defined(OPENSSL_NO_EC2M)
                } else if (id == s_GF2m) {
                    new_curve = EC_GROUP_new_curve_GF2m;
    #endif
                } else {
                    ossl_raise(rb_eArgError, "unknown symbol, must be :GFp or :GF2m");
                }

                if ((group = new_curve(p, a, b, ossl_bn_ctx)) == NULL)
                    ossl_raise(eEC_GROUP, "EC_GROUP_new_by_GF*");
            } else {
                 ossl_raise(rb_eArgError, "unknown argument, must be :GFp or :GF2m");
            }

            break;
        default:
            ossl_raise(rb_eArgError, "wrong number of arguments");
        }

        if (group == NULL)
            ossl_raise(eEC_GROUP, "");
        RTYPEDDATA_DATA(self) = group;

        return self;
    }

### Public Instance Methods

==(p1) click to toggle source
Alias for: eql?
asn1_flag → Integer click to toggle source

Returns the flags set on the group.

See also `asn1_flag=`.

                   static VALUE ossl_ec_group_get_asn1_flag(VALUE self)
    {
        EC_GROUP *group = NULL;
        int flag;

        GetECGroup(self, group);
        flag = EC_GROUP_get_asn1_flag(group);

        return INT2NUM(flag);
    }

asn1_flag = flags click to toggle source

Sets flags on the group. The flag value is used to determine how to encode the group: encode explicit parameters or named curve using an OID.

The flag value can be either of:

- EC::NAMED_CURVE

- EC::EXPLICIT_CURVE

See the `OpenSSL` documentation for EC_GROUP_set_asn1_flag().

                   static VALUE ossl_ec_group_set_asn1_flag(VALUE self, VALUE flag_v)
    {
        EC_GROUP *group = NULL;

        GetECGroup(self, group);
        EC_GROUP_set_asn1_flag(group, NUM2INT(flag_v));

        return flag_v;
    }

get_cofactor => cofactor_bn click to toggle source

Returns the cofactor of the group.

See the `OpenSSL` documentation for EC_GROUP_get_cofactor()

                   static VALUE ossl_ec_group_get_cofactor(VALUE self)
    {
        VALUE bn_obj;
        BIGNUM *bn;
        EC_GROUP *group = NULL;

        GetECGroup(self, group);

        bn_obj = ossl_bn_new(NULL);
        bn = GetBNPtr(bn_obj);

        if (EC_GROUP_get_cofactor(group, bn, ossl_bn_ctx) != 1)
            ossl_raise(eEC_GROUP, "EC_GROUP_get_cofactor");

        return bn_obj;
    }

curve_name => String click to toggle source

Returns the curve name (sn).

See the `OpenSSL` documentation for EC_GROUP_get_curve_name()

                   static VALUE ossl_ec_group_get_curve_name(VALUE self)
    {
        EC_GROUP *group = NULL;
        int nid;

        GetECGroup(self, group);
        if (group == NULL)
            return Qnil;

        nid = EC_GROUP_get_curve_name(group);

    /* BUG: an nid or asn1 object should be returned, maybe. */
        return rb_str_new2(OBJ_nid2sn(nid));
    }

degree => integer click to toggle source

See the `OpenSSL` documentation for EC_GROUP_get_degree()

                   static VALUE ossl_ec_group_get_degree(VALUE self)
    {
        EC_GROUP *group = NULL;

        GetECGroup(self, group);

        return INT2NUM(EC_GROUP_get_degree(group));
    }

eql?(group2) => true | false click to toggle source
group1 == group2 => true | false

Returns `true` if the two groups use the same curve and have the same parameters, `false` otherwise.

                   static VALUE ossl_ec_group_eql(VALUE a, VALUE b)
    {
        EC_GROUP *group1 = NULL, *group2 = NULL;

        GetECGroup(a, group1);
        GetECGroup(b, group2);

        if (EC_GROUP_cmp(group1, group2, ossl_bn_ctx) == 1)
           return Qfalse;

        return Qtrue;
    }

Also aliased as: ==
generator => ec_point click to toggle source

Returns the generator of the group.

See the `OpenSSL` documentation for EC_GROUP_get0_generator()

                   static VALUE ossl_ec_group_get_generator(VALUE self)
    {
        EC_GROUP *group;
        const EC_POINT *generator;

        GetECGroup(self, group);
        generator = EC_GROUP_get0_generator(group);
        if (!generator)
            return Qnil;

        return ec_point_new(generator, group);
    }

initialize_copy(p1) click to toggle source

                   static VALUE
    ossl_ec_group_initialize_copy(VALUE self, VALUE other)
    {
        EC_GROUP *group, *group_new;

        TypedData_Get_Struct(self, EC_GROUP, &ossl_ec_group_type, group_new);
        if (group_new)
            ossl_raise(eEC_GROUP, "EC::Group already initialized");
        GetECGroup(other, group);

        group_new = EC_GROUP_dup(group);
        if (!group_new)
            ossl_raise(eEC_GROUP, "EC_GROUP_dup");
        RTYPEDDATA_DATA(self) = group_new;

        return self;
    }

get_order => order_bn click to toggle source

Returns the order of the group.

See the `OpenSSL` documentation for EC_GROUP_get_order()

                   static VALUE ossl_ec_group_get_order(VALUE self)
    {
        VALUE bn_obj;
        BIGNUM *bn;
        EC_GROUP *group = NULL;

        GetECGroup(self, group);

        bn_obj = ossl_bn_new(NULL);
        bn = GetBNPtr(bn_obj);

        if (EC_GROUP_get_order(group, bn, ossl_bn_ctx) != 1)
            ossl_raise(eEC_GROUP, "EC_GROUP_get_order");

        return bn_obj;
    }

point_conversion_form → Symbol click to toggle source

Returns the form how `EC::Point` data is encoded as ASN.1.

See also `point_conversion_form=`.

                   static VALUE ossl_ec_group_get_point_conversion_form(VALUE self)
    {
        EC_GROUP *group = NULL;
        point_conversion_form_t form;
        VALUE ret;

        GetECGroup(self, group);
        form = EC_GROUP_get_point_conversion_form(group);

        switch (form) {
        case POINT_CONVERSION_UNCOMPRESSED: ret = ID_uncompressed; break;
        case POINT_CONVERSION_COMPRESSED:   ret = ID_compressed; break;
        case POINT_CONVERSION_HYBRID:       ret = ID_hybrid; break;
        default:    ossl_raise(eEC_GROUP, "unsupported point conversion form: %d, this module should be updated", form);
        }

       return ID2SYM(ret);
    }

point_conversion_form = form click to toggle source

Sets the form how `EC::Point` data is encoded as ASN.1 as defined in X9.62.

format can be one of these:

`:compressed`

  Encoded as z||x, where z is an octet indicating which solution of the equation y is. z will be 0x02 or 0x03.

`:uncompressed`

  Encoded as z||x||y, where z is an octet 0x04.

`:hybrid`

  Encodes as z||x||y, where z is an octet indicating which solution of the equation y is. z will be 0x06 or 0x07.

See the `OpenSSL` documentation for EC_GROUP_set_point_conversion_form()

                   static VALUE
    ossl_ec_group_set_point_conversion_form(VALUE self, VALUE form_v)
    {
        EC_GROUP *group;
        point_conversion_form_t form;

        GetECGroup(self, group);
        form = parse_point_conversion_form_symbol(form_v);

        EC_GROUP_set_point_conversion_form(group, form);

        return form_v;
    }

seed => String or nil click to toggle source

See the `OpenSSL` documentation for EC_GROUP_get0_seed()

                   static VALUE ossl_ec_group_get_seed(VALUE self)
    {
        EC_GROUP *group = NULL;
        size_t seed_len;

        GetECGroup(self, group);
        seed_len = EC_GROUP_get_seed_len(group);

        if (seed_len == 0)
            return Qnil;

        return rb_str_new((const char *)EC_GROUP_get0_seed(group), seed_len);
    }

seed = seed => seed click to toggle source

See the `OpenSSL` documentation for EC_GROUP_set_seed()

                   static VALUE ossl_ec_group_set_seed(VALUE self, VALUE seed)
    {
        EC_GROUP *group = NULL;

        GetECGroup(self, group);
        StringValue(seed);

        if (EC_GROUP_set_seed(group, (unsigned char *)RSTRING_PTR(seed), RSTRING_LEN(seed)) != (size_t)RSTRING_LEN(seed))
            ossl_raise(eEC_GROUP, "EC_GROUP_set_seed");

        return seed;
    }

set_generator(generator, order, cofactor) => self click to toggle source

Sets the curve parameters. generator must be an instance of `EC::Point` that is on the curve. order and cofactor are integers.

See the `OpenSSL` documentation for EC_GROUP_set_generator()

                   static VALUE ossl_ec_group_set_generator(VALUE self, VALUE generator, VALUE order, VALUE cofactor)
    {
        EC_GROUP *group = NULL;
        const EC_POINT *point;
        const BIGNUM *o, *co;

        GetECGroup(self, group);
        GetECPoint(generator, point);
        o = GetBNPtr(order);
        co = GetBNPtr(cofactor);

        if (EC_GROUP_set_generator(group, point, o, co) != 1)
            ossl_raise(eEC_GROUP, "EC_GROUP_set_generator");

        return self;
    }

to_der => String click to toggle source

See the `OpenSSL` documentation for i2d_ECPKParameters_bio()

                   static VALUE ossl_ec_group_to_der(VALUE self)
    {
        return ossl_ec_group_to_string(self, EXPORT_DER);
    }

to_pem => String click to toggle source

See the `OpenSSL` documentation for PEM_write_bio_ECPKParameters()

                   static VALUE ossl_ec_group_to_pem(VALUE self)
    {
        return ossl_ec_group_to_string(self, EXPORT_PEM);
    }

to_text => String click to toggle source

See the `OpenSSL` documentation for ECPKParameters_print()

                   static VALUE ossl_ec_group_to_text(VALUE self)
    {
        EC_GROUP *group;
        BIO *out;
        VALUE str;

        GetECGroup(self, group);
        if (!(out = BIO_new(BIO_s_mem()))) {
            ossl_raise(eEC_GROUP, "BIO_new(BIO_s_mem())");
        }
        if (!ECPKParameters_print(out, group, 0)) {
            BIO_free(out);
            ossl_raise(eEC_GROUP, NULL);
        }
        str = ossl_membio2str(out);

        return str;
    }