Class: OpenSSL::PKey::EC::Point
- Inherits:
-
Object
- Object
- OpenSSL::PKey::EC::Point
- Defined in:
- lib/openssl/pkey.rb,
ext/openssl/ossl_pkey_ec.c
Defined Under Namespace
Classes: Error
Instance Method Summary collapse
-
#add(point) ⇒ Object
Performs elliptic curve point addition.
- #eql?(b) ⇒ Boolean (also: #==)
- #infinity? ⇒ Boolean
-
#initialize(*args) ⇒ Object
constructor
Creates a new instance of OpenSSL::PKey::EC::Point.
- #initialize_copy(other) ⇒ Object
- #invert! ⇒ self
-
#make_affine! ⇒ self
This method is deprecated and should not be used.
-
#mul(*args) ⇒ Object
Performs elliptic curve point multiplication.
- #on_curve? ⇒ Boolean
- #set_to_infinity! ⇒ self
-
#to_bn(conversion_form = group.point_conversion_form) ⇒ Object
:call-seq: point.to_bn() -> OpenSSL::BN.
-
#to_octet_string(conversion_form) ⇒ String
Returns the octet string representation of the elliptic curve point.
Constructor Details
#OpenSSL::PKey::EC::Point.new(point) ⇒ Object #OpenSSL::PKey::EC::Point.new(group[, encoded_point]) ⇒ Object
Creates a new instance of OpenSSL::PKey::EC::Point. If the only argument is an instance of EC::Point, a copy is returned. Otherwise, creates a point that belongs to group.
encoded_point is the octet string representation of the point. This must be either a String or an OpenSSL::BN.
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1139
static VALUE ossl_ec_point_initialize(int argc, VALUE *argv, VALUE self)
{
EC_POINT *point;
VALUE group_v, arg2;
const EC_GROUP *group;
TypedData_Get_Struct(self, EC_POINT, &ossl_ec_point_type, point);
if (point)
rb_raise(eEC_POINT, "EC_POINT already initialized");
rb_scan_args(argc, argv, "11", &group_v, &arg2);
if (rb_obj_is_kind_of(group_v, cEC_POINT)) {
if (argc != 1)
rb_raise(rb_eArgError, "invalid second argument");
return ossl_ec_point_initialize_copy(self, group_v);
}
GetECGroup(group_v, group);
if (argc == 1) {
point = EC_POINT_new(group);
if (!point)
ossl_raise(eEC_POINT, "EC_POINT_new");
}
else {
if (rb_obj_is_kind_of(arg2, cBN)) {
point = EC_POINT_bn2point(group, GetBNPtr(arg2), NULL, ossl_bn_ctx);
if (!point)
ossl_raise(eEC_POINT, "EC_POINT_bn2point");
}
else {
StringValue(arg2);
point = EC_POINT_new(group);
if (!point)
ossl_raise(eEC_POINT, "EC_POINT_new");
if (!EC_POINT_oct2point(group, point,
(unsigned char *)RSTRING_PTR(arg2),
RSTRING_LEN(arg2), ossl_bn_ctx)) {
EC_POINT_free(point);
ossl_raise(eEC_POINT, "EC_POINT_oct2point");
}
}
}
RTYPEDDATA_DATA(self) = point;
rb_ivar_set(self, id_i_group, group_v);
return self;
}
|
Instance Method Details
#add(point) ⇒ Object
Performs elliptic curve point addition.
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1380
static VALUE ossl_ec_point_add(VALUE self, VALUE other)
{
EC_POINT *point_self, *point_other, *point_result;
const EC_GROUP *group;
VALUE group_v = rb_attr_get(self, id_i_group);
VALUE result;
GetECPoint(self, point_self);
GetECPoint(other, point_other);
GetECGroup(group_v, group);
result = rb_obj_alloc(cEC_POINT);
ossl_ec_point_initialize(1, &group_v, result);
GetECPoint(result, point_result);
if (EC_POINT_add(group, point_result, point_self, point_other, ossl_bn_ctx) != 1) {
ossl_raise(eEC_POINT, "EC_POINT_add");
}
return result;
}
|
#eql?(point2) ⇒ Boolean #==(point2) ⇒ Boolean Also known as: ==
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1217
static VALUE ossl_ec_point_eql(VALUE a, VALUE b)
{
EC_POINT *point1, *point2;
VALUE group_v1 = rb_attr_get(a, id_i_group);
VALUE group_v2 = rb_attr_get(b, id_i_group);
const EC_GROUP *group;
if (ossl_ec_group_eql(group_v1, group_v2) == Qfalse)
return Qfalse;
GetECPoint(a, point1);
GetECPoint(b, point2);
GetECGroup(group_v1, group);
if (EC_POINT_cmp(group, point1, point2, ossl_bn_ctx) == 1)
return Qfalse;
return Qtrue;
}
|
#infinity? ⇒ Boolean
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1241
static VALUE ossl_ec_point_is_at_infinity(VALUE self)
{
EC_POINT *point;
const EC_GROUP *group;
GetECPoint(self, point);
GetECPointGroup(self, group);
switch (EC_POINT_is_at_infinity(group, point)) {
case 1: return Qtrue;
case 0: return Qfalse;
default: ossl_raise(cEC_POINT, "EC_POINT_is_at_infinity");
}
UNREACHABLE;
}
|
#initialize_copy(other) ⇒ Object
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1188
static VALUE
ossl_ec_point_initialize_copy(VALUE self, VALUE other)
{
EC_POINT *point, *point_new;
EC_GROUP *group;
VALUE group_v;
TypedData_Get_Struct(self, EC_POINT, &ossl_ec_point_type, point_new);
if (point_new)
ossl_raise(eEC_POINT, "EC::Point already initialized");
GetECPoint(other, point);
group_v = rb_obj_dup(rb_attr_get(other, id_i_group));
GetECGroup(group_v, group);
point_new = EC_POINT_dup(point, group);
if (!point_new)
ossl_raise(eEC_POINT, "EC_POINT_dup");
RTYPEDDATA_DATA(self) = point_new;
rb_ivar_set(self, id_i_group, group_v);
return self;
}
|
#invert! ⇒ self
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1306
static VALUE ossl_ec_point_invert(VALUE self)
{
EC_POINT *point;
const EC_GROUP *group;
GetECPoint(self, point);
GetECPointGroup(self, group);
if (EC_POINT_invert(group, point, ossl_bn_ctx) != 1)
ossl_raise(cEC_POINT, "EC_POINT_invert");
return self;
}
|
#make_affine! ⇒ self
This method is deprecated and should not be used. This is a no-op.
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1285
static VALUE ossl_ec_point_make_affine(VALUE self)
{
EC_POINT *point;
const EC_GROUP *group;
GetECPoint(self, point);
GetECPointGroup(self, group);
rb_warn("OpenSSL::PKey::EC::Point#make_affine! is deprecated");
#if !OSSL_OPENSSL_PREREQ(3, 0, 0)
if (EC_POINT_make_affine(group, point, ossl_bn_ctx) != 1)
ossl_raise(cEC_POINT, "EC_POINT_make_affine");
#endif
return self;
}
|
#mul(bn1[, bn2]) ⇒ Object #mul(bns, points[, bn2]) ⇒ Object
Performs elliptic curve point multiplication.
The first form calculates bn1 * point + bn2 * G
, where G
is the generator of the group of point. bn2 may be omitted, and in that case, the result is just bn1 * point
.
The second form calculates bns[0] * point + bns[1] * points[0] + ... + bns[-1] * points[-1] + bn2 * G
. bn2 may be omitted. bns must be an array of OpenSSL::BN. points must be an array of OpenSSL::PKey::EC::Point. Please note that points[0]
is not multiplied by bns[0]
, but bns[1]
.
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1419
static VALUE ossl_ec_point_mul(int argc, VALUE *argv, VALUE self)
{
EC_POINT *point_self, *point_result;
const EC_GROUP *group;
VALUE group_v = rb_attr_get(self, id_i_group);
VALUE arg1, arg2, arg3, result;
const BIGNUM *bn_g = NULL;
GetECPoint(self, point_self);
GetECGroup(group_v, group);
result = rb_obj_alloc(cEC_POINT);
ossl_ec_point_initialize(1, &group_v, result);
GetECPoint(result, point_result);
rb_scan_args(argc, argv, "12", &arg1, &arg2, &arg3);
if (!RB_TYPE_P(arg1, T_ARRAY)) {
BIGNUM *bn = GetBNPtr(arg1);
if (!NIL_P(arg2))
bn_g = GetBNPtr(arg2);
if (EC_POINT_mul(group, point_result, bn_g, point_self, bn, ossl_bn_ctx) != 1)
ossl_raise(eEC_POINT, NULL);
} else {
#if (defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3) || defined(LIBRESSL_VERSION_NUMBER)
rb_raise(rb_eNotImpError, "calling #mul with arrays is not" \
"supported by this OpenSSL version");
#else
/*
* bignums | arg1[0] | arg1[1] | arg1[2] | ...
* points | self | arg2[0] | arg2[1] | ...
*/
long i, num;
VALUE bns_tmp, tmp_p, tmp_b;
const EC_POINT **points;
const BIGNUM **bignums;
Check_Type(arg1, T_ARRAY);
Check_Type(arg2, T_ARRAY);
if (RARRAY_LEN(arg1) != RARRAY_LEN(arg2) + 1) /* arg2 must be 1 larger */
ossl_raise(rb_eArgError, "bns must be 1 longer than points; see the documentation");
rb_warning("OpenSSL::PKey::EC::Point#mul(ary, ary) is deprecated; " \
"use #mul(bn) form instead");
num = RARRAY_LEN(arg1);
bns_tmp = rb_ary_tmp_new(num);
bignums = ALLOCV_N(const BIGNUM *, tmp_b, num);
for (i = 0; i < num; i++) {
VALUE item = RARRAY_AREF(arg1, i);
bignums[i] = GetBNPtr(item);
rb_ary_push(bns_tmp, item);
}
points = ALLOCV_N(const EC_POINT *, tmp_p, num);
points[0] = point_self; /* self */
for (i = 0; i < num - 1; i++)
GetECPoint(RARRAY_AREF(arg2, i), points[i + 1]);
if (!NIL_P(arg3))
bn_g = GetBNPtr(arg3);
if (EC_POINTs_mul(group, point_result, bn_g, num, points, bignums, ossl_bn_ctx) != 1) {
ALLOCV_END(tmp_b);
ALLOCV_END(tmp_p);
ossl_raise(eEC_POINT, NULL);
}
ALLOCV_END(tmp_b);
ALLOCV_END(tmp_p);
#endif
}
return result;
}
|
#on_curve? ⇒ Boolean
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1262
static VALUE ossl_ec_point_is_on_curve(VALUE self)
{
EC_POINT *point;
const EC_GROUP *group;
GetECPoint(self, point);
GetECPointGroup(self, group);
switch (EC_POINT_is_on_curve(group, point, ossl_bn_ctx)) {
case 1: return Qtrue;
case 0: return Qfalse;
default: ossl_raise(cEC_POINT, "EC_POINT_is_on_curve");
}
UNREACHABLE;
}
|
#set_to_infinity! ⇒ self
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1324
static VALUE ossl_ec_point_set_to_infinity(VALUE self)
{
EC_POINT *point;
const EC_GROUP *group;
GetECPoint(self, point);
GetECPointGroup(self, group);
if (EC_POINT_set_to_infinity(group, point) != 1)
ossl_raise(cEC_POINT, "EC_POINT_set_to_infinity");
return self;
}
|
#to_bn(conversion_form = group.point_conversion_form) ⇒ Object
:call-seq:
point.to_bn([conversion_form]) -> OpenSSL::BN
Returns the octet string representation of the EC point as an instance of OpenSSL::BN.
If conversion_form is not given, the point_conversion_form attribute set to the group is used.
See #to_octet_string for more information.
299 300 301 |
# File 'lib/openssl/pkey.rb', line 299 def to_bn(conversion_form = group.point_conversion_form) OpenSSL::BN.new(to_octet_string(conversion_form), 2) end |
#to_octet_string(conversion_form) ⇒ String
Returns the octet string representation of the elliptic curve point.
conversion_form specifies how the point is converted. Possible values are:
-
:compressed
-
:uncompressed
-
:hybrid
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 |
# File 'ext/openssl/ossl_pkey_ec.c', line 1350
static VALUE
ossl_ec_point_to_octet_string(VALUE self, VALUE conversion_form)
{
EC_POINT *point;
const EC_GROUP *group;
point_conversion_form_t form;
VALUE str;
size_t len;
GetECPoint(self, point);
GetECPointGroup(self, group);
form = parse_point_conversion_form_symbol(conversion_form);
len = EC_POINT_point2oct(group, point, form, NULL, 0, ossl_bn_ctx);
if (!len)
ossl_raise(eEC_POINT, "EC_POINT_point2oct");
str = rb_str_new(NULL, (long)len);
if (!EC_POINT_point2oct(group, point, form,
(unsigned char *)RSTRING_PTR(str), len,
ossl_bn_ctx))
ossl_raise(eEC_POINT, "EC_POINT_point2oct");
return str;
}
|