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 [+]

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