OpenSSL::PKey::EC::Group

class OpenSSL::PKey::EC::Group

父类:Object

公共类方法

OpenSSL::PKey::EC::Group.new(ec_group) 显示源

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)

创建一个新的EC :: Group对象。

ec_method是代表EC_METHOD的符号。目前支持以下内容：

：GFp_simple

:GFp_mont

:GFp_nist

:GF2m_simple

如果第一个参数是：GFp或：GF2m，则创建一个具有给定参数的新曲线。

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;

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

公共实例方法

==(p1)

别名为：eql

asn1_flag → Integer 显示源

返回组中设置的标志。

另请参阅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 显示源

设置组上的标志。标志值用于确定如何编码组：使用OID编码显式参数或命名曲线。

标志值可以是以下任一项：

EC::NAMED_CURVE

EC::EXPLICIT_CURVE

有关EC_GROUP_set_asn1_flag（）的信息，请参阅OpenSSL文档。

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 显示源

返回组的辅助因子。

请参阅EC_GROUP_get_cofactor（）的OpenSSL文档

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 显示源

返回曲线名称（sn）。

有关EC_GROUP_get_curve_name（）的信息，请参阅OpenSSL文档

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 显示源

有关EC_GROUP_get_degree（）的信息，请参阅OpenSSL文档

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 显示源

group1 == group2 → true | false

如果两个组使用相同的曲线并具有相同的参数，则返回true，否则返回false。

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

    GetECGroup(a, group1
    SafeGetECGroup(b, group2

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

    return Qtrue;
}

另外别名为：==

generator → ec_point 显示源

返回组的生成器。

请参阅EC_GROUP_get0_generator（）的OpenSSL文档

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
}

get_order → order_bn 显示源

返回组的顺序。

请参阅EC_GROUP_get_order（）的OpenSSL文档

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 显示源

返回EC :: Point数据如何编码为ASN.1的形式。

另请参阅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 显示源

按照X9.62中的定义，设置EC :: Point数据如何编码为ASN.1的形式。

format 可以是其中之一：

:compressed

编码为z || x，其中z是一个八位位组，指示方程y的哪个解。z将是0x02或0x03。

:uncompressed

编码为z || x || y，其中z是一个八位位组0x04。

:hybrid

编码为z || x || y，其中z是指示方程y的哪个解的八位字节。z将是0x06或0x07。

有关EC_GROUP_set_point_conversion_form（）的信息，请参阅OpenSSL文档

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 显示源

有关EC_GROUP_get0_seed（）的信息，请参阅OpenSSL文档

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 显示源

请参阅EC_GROUP_set_seed（）的OpenSSL文档

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 显示源

设置曲线参数。generator必须是曲线上的EC :: Point的实例。order并且cofactor是整数。

请参阅EC_GROUP_set_generator（）的OpenSSL文档

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
    SafeGetECPoint(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显示源

有关i2d_ECPKParameters_bio（）的信息，请参阅OpenSSL文档

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

to_pem → String 显示源

请参阅PEM_write_bio_ECPKParameters（）的OpenSSL文档

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

to_text → String 显示源

有关ECPKParameters_print（）的信息，请参阅OpenSSL文档

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