W3cubDocs

/Ruby 4.0

class OpenSSL::PKey::EC::Group

Parent:: Object

Public Class Methods

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 (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);
#if !defined(OPENSSL_IS_AWSLC)
                group = EC_GROUP_new_by_curve_name(nid);
#else /* EC_GROUPs are static and immutable by default in AWS-LC. */
                group = EC_GROUP_new_by_curve_name_mutable(nid);
#endif
                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)) {
            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 (arg1 == sym_GFp) {
                new_curve = EC_GROUP_new_curve_GFp;
            }
#if !defined(OPENSSL_NO_EC2M)
            else if (arg1 == sym_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");
    }

    ASSUME(group);
    RTYPEDDATA_DATA(self) = group;

    return self;
}

OpenSSL::PKey::EC::Group.new(ec_group) Show source

OpenSSL::PKey::EC::Group.new(pem_or_der_encoded)

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.

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

Public Instance Methods

group1 == group2 → true | false

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

Alias for: eql?

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 → Integer Show source

Returns the flags set on the group.

See also 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;
}

asn1_flag = flags Show 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_get_cofactor(VALUE self)
{
    VALUE bn_obj;
    BIGNUM *bn;
    EC_GROUP *group;

    GetECGroup(self, group);
    bn_obj = ossl_bn_new(BN_value_one());
    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;
}

get_cofactor → cofactor_bn Show source

Returns the cofactor of the group.

See the OpenSSL documentation for EC_GROUP_get_cofactor()

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

    GetECGroup(self, group);
    nid = EC_GROUP_get_curve_name(group);
    if (nid == NID_undef)
        return Qnil;
    return rb_str_new_cstr(OBJ_nid2sn(nid));
}

curve_name → string or nil Show source

Returns the curve name (short name) corresponding to this group, or nil if OpenSSL does not have an OID associated with the group.

See the OpenSSL documentation for EC_GROUP_get_curve_name()

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

    GetECGroup(self, group);

    return INT2NUM(EC_GROUP_get_degree(group));
}

degree → integer Show source

See the OpenSSL documentation for EC_GROUP_get_degree()

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

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

    switch (EC_GROUP_cmp(group1, group2, ossl_bn_ctx)) {
      case 0: return Qtrue;
      case 1: return Qfalse;
      default: ossl_raise(eEC_GROUP, "EC_GROUP_cmp");
    }
}

eql?(group2) → true | false Show source

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

Also aliased as: ==

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

generator → ec_point Show source

Returns the generator of the group.

See the OpenSSL documentation for EC_GROUP_get0_generator()

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

    GetECGroup(self, group);
    bn_obj = ossl_bn_new(BN_value_one());
    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;
}

get_order → order_bn Show source

Returns the order of the group.

See the OpenSSL documentation for EC_GROUP_get_order()

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

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

    switch (form) {
      case POINT_CONVERSION_UNCOMPRESSED:
        return sym_uncompressed;
      case POINT_CONVERSION_COMPRESSED:
        return sym_compressed;
      case POINT_CONVERSION_HYBRID:
        return sym_hybrid;
      default:
        ossl_raise(eEC_GROUP, "unsupported point conversion form: %d, " \
                   "this module should be updated", form);
    }
}

point_conversion_form → Symbol Show source

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

See also 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;
}

point_conversion_form = form Show 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_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 → String or nil Show source

See the OpenSSL documentation for EC_GROUP_get0_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;
}

seed = seed → seed Show source

See the OpenSSL documentation for EC_GROUP_set_seed()

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

set_generator(generator, order, cofactor) → self Show 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_to_der(VALUE self)
{
    return ossl_ec_group_to_string(self, EXPORT_DER);
}

to_der → String Show source

See the OpenSSL documentation for i2d_ECPKParameters_bio()

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

to_pem → String Show source

See the OpenSSL documentation for PEM_write_bio_ECPKParameters()

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

to_text → String Show source

See the OpenSSL documentation for ECPKParameters_print()

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