Wei Lu
11 years ago
14 changed files with 79 additions and 734 deletions
@ -1,419 +0,0 @@ |
|||
// Basic Javascript Elliptic Curve implementation
|
|||
// Ported loosely from BouncyCastle's Java EC code
|
|||
// Only Fp curves implemented for now
|
|||
|
|||
var assert = require('assert') |
|||
var BigInteger = require('bigi') |
|||
|
|||
// constants
|
|||
var THREE = BigInteger.valueOf(3) |
|||
|
|||
function ECFieldElementFp(q,x) { |
|||
this.x = x |
|||
// TODO if (x.compareTo(q) >= 0) error
|
|||
this.q = q |
|||
} |
|||
|
|||
function feFpEquals(other) { |
|||
if (other == this) return true |
|||
return (this.q.equals(other.q) && this.x.equals(other.x)) |
|||
} |
|||
|
|||
function feFpToBigInteger() { |
|||
return this.x |
|||
} |
|||
|
|||
function feFpNegate() { |
|||
return new ECFieldElementFp(this.q, this.x.negate().mod(this.q)) |
|||
} |
|||
|
|||
function feFpAdd(b) { |
|||
return new ECFieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q)) |
|||
} |
|||
|
|||
function feFpSubtract(b) { |
|||
return new ECFieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q)) |
|||
} |
|||
|
|||
function feFpMultiply(b) { |
|||
return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q)) |
|||
} |
|||
|
|||
function feFpSquare() { |
|||
return new ECFieldElementFp(this.q, this.x.square().mod(this.q)) |
|||
} |
|||
|
|||
function feFpDivide(b) { |
|||
return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q)) |
|||
} |
|||
|
|||
ECFieldElementFp.prototype.equals = feFpEquals |
|||
ECFieldElementFp.prototype.toBigInteger = feFpToBigInteger |
|||
ECFieldElementFp.prototype.negate = feFpNegate |
|||
ECFieldElementFp.prototype.add = feFpAdd |
|||
ECFieldElementFp.prototype.subtract = feFpSubtract |
|||
ECFieldElementFp.prototype.multiply = feFpMultiply |
|||
ECFieldElementFp.prototype.square = feFpSquare |
|||
ECFieldElementFp.prototype.divide = feFpDivide |
|||
|
|||
// ----------------
|
|||
// ECPointFp
|
|||
|
|||
// constructor
|
|||
function ECPointFp(curve,x,y,z) { |
|||
this.curve = curve |
|||
this.x = x |
|||
this.y = y |
|||
|
|||
// Projective coordinates: either zinv == null or z * zinv == 1
|
|||
// z and zinv are just BigIntegers, not fieldElements
|
|||
this.z = (z == undefined) ? BigInteger.ONE : z |
|||
this.zinv = null |
|||
|
|||
//TODO: compression flag
|
|||
} |
|||
|
|||
function pointFpGetX() { |
|||
if (this.zinv === null) { |
|||
this.zinv = this.z.modInverse(this.curve.q) |
|||
} |
|||
|
|||
return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q)) |
|||
} |
|||
|
|||
function pointFpGetY() { |
|||
if (this.zinv === null) { |
|||
this.zinv = this.z.modInverse(this.curve.q) |
|||
} |
|||
|
|||
return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q)) |
|||
} |
|||
|
|||
function pointFpEquals(other) { |
|||
if (other == this) return true |
|||
if (this.isInfinity()) return other.isInfinity() |
|||
if (other.isInfinity()) return this.isInfinity() |
|||
|
|||
// u = Y2 * Z1 - Y1 * Z2
|
|||
var u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q) |
|||
|
|||
if (u.signum() !== 0) return false |
|||
|
|||
// v = X2 * Z1 - X1 * Z2
|
|||
var v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q) |
|||
|
|||
return v.signum() === 0 |
|||
} |
|||
|
|||
function pointFpIsInfinity() { |
|||
if ((this.x === null) && (this.y === null)) return true |
|||
return this.z.signum() === 0 && this.y.toBigInteger().signum() !== 0 |
|||
} |
|||
|
|||
function pointFpNegate() { |
|||
return new ECPointFp(this.curve, this.x, this.y.negate(), this.z) |
|||
} |
|||
|
|||
function pointFpAdd(b) { |
|||
if (this.isInfinity()) return b |
|||
if (b.isInfinity()) return this |
|||
|
|||
var x1 = this.x.toBigInteger() |
|||
var y1 = this.y.toBigInteger() |
|||
var x2 = b.x.toBigInteger() |
|||
var y2 = b.y.toBigInteger() |
|||
|
|||
// u = Y2 * Z1 - Y1 * Z2
|
|||
var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.q) |
|||
// v = X2 * Z1 - X1 * Z2
|
|||
var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.q) |
|||
|
|||
if (v.signum() === 0) { |
|||
if (u.signum() === 0) { |
|||
return this.twice() // this == b, so double
|
|||
} |
|||
|
|||
return this.curve.getInfinity() // this = -b, so infinity
|
|||
} |
|||
|
|||
var v2 = v.square() |
|||
var v3 = v2.multiply(v) |
|||
var x1v2 = x1.multiply(v2) |
|||
var zu2 = u.square().multiply(this.z) |
|||
|
|||
// x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
|
|||
var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.q) |
|||
// y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
|
|||
var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.q) |
|||
// z3 = v^3 * z1 * z2
|
|||
var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.q) |
|||
|
|||
return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3) |
|||
} |
|||
|
|||
function pointFpTwice() { |
|||
if (this.isInfinity()) return this |
|||
if (this.y.toBigInteger().signum() === 0) return this.curve.getInfinity() |
|||
|
|||
var x1 = this.x.toBigInteger() |
|||
var y1 = this.y.toBigInteger() |
|||
|
|||
var y1z1 = y1.multiply(this.z) |
|||
var y1sqz1 = y1z1.multiply(y1).mod(this.curve.q) |
|||
var a = this.curve.a.toBigInteger() |
|||
|
|||
// w = 3 * x1^2 + a * z1^2
|
|||
var w = x1.square().multiply(THREE) |
|||
|
|||
if (a.signum() !== 0) { |
|||
w = w.add(this.z.square().multiply(a)) |
|||
} |
|||
|
|||
w = w.mod(this.curve.q) |
|||
// x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
|
|||
var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.q) |
|||
// y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
|
|||
var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.q) |
|||
// z3 = 8 * (y1 * z1)^3
|
|||
var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.q) |
|||
|
|||
return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3) |
|||
} |
|||
|
|||
// Simple NAF (Non-Adjacent Form) multiplication algorithm
|
|||
// TODO: modularize the multiplication algorithm
|
|||
function pointFpMultiply(k) { |
|||
if (this.isInfinity()) return this |
|||
if (k.signum() === 0) return this.curve.getInfinity() |
|||
|
|||
var e = k |
|||
var h = e.multiply(THREE) |
|||
|
|||
var neg = this.negate() |
|||
var R = this |
|||
|
|||
for (var i = h.bitLength() - 2; i > 0; --i) { |
|||
R = R.twice() |
|||
|
|||
var hBit = h.testBit(i) |
|||
var eBit = e.testBit(i) |
|||
|
|||
if (hBit != eBit) { |
|||
R = R.add(hBit ? this : neg) |
|||
} |
|||
} |
|||
|
|||
return R |
|||
} |
|||
|
|||
// Compute this*j + x*k (simultaneous multiplication)
|
|||
function pointFpMultiplyTwo(j,x,k) { |
|||
var i |
|||
|
|||
if (j.bitLength() > k.bitLength()) |
|||
i = j.bitLength() - 1 |
|||
else |
|||
i = k.bitLength() - 1 |
|||
|
|||
var R = this.curve.getInfinity() |
|||
var both = this.add(x) |
|||
while (i >= 0) { |
|||
R = R.twice() |
|||
if (j.testBit(i)) { |
|||
if (k.testBit(i)) { |
|||
R = R.add(both) |
|||
} |
|||
else { |
|||
R = R.add(this) |
|||
} |
|||
} |
|||
else { |
|||
if (k.testBit(i)) { |
|||
R = R.add(x) |
|||
} |
|||
} |
|||
--i |
|||
} |
|||
|
|||
return R |
|||
} |
|||
|
|||
ECPointFp.prototype.getX = pointFpGetX |
|||
ECPointFp.prototype.getY = pointFpGetY |
|||
ECPointFp.prototype.equals = pointFpEquals |
|||
ECPointFp.prototype.isInfinity = pointFpIsInfinity |
|||
ECPointFp.prototype.negate = pointFpNegate |
|||
ECPointFp.prototype.add = pointFpAdd |
|||
ECPointFp.prototype.twice = pointFpTwice |
|||
ECPointFp.prototype.multiply = pointFpMultiply |
|||
ECPointFp.prototype.multiplyTwo = pointFpMultiplyTwo |
|||
|
|||
// ----------------
|
|||
// ECCurveFp
|
|||
|
|||
// constructor
|
|||
function ECCurveFp(q,a,b) { |
|||
this.q = q |
|||
this.a = this.fromBigInteger(a) |
|||
this.b = this.fromBigInteger(b) |
|||
this.infinity = new ECPointFp(this, null, null) |
|||
} |
|||
|
|||
function curveFpGetQ() { |
|||
return this.q |
|||
} |
|||
|
|||
function curveFpGetA() { |
|||
return this.a |
|||
} |
|||
|
|||
function curveFpGetB() { |
|||
return this.b |
|||
} |
|||
|
|||
function curveFpEquals(other) { |
|||
if (other == this) return true |
|||
return(this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b)) |
|||
} |
|||
|
|||
function curveFpGetInfinity() { |
|||
return this.infinity |
|||
} |
|||
|
|||
function curveFpFromBigInteger(x) { |
|||
return new ECFieldElementFp(this.q, x) |
|||
} |
|||
|
|||
ECCurveFp.prototype.getQ = curveFpGetQ |
|||
ECCurveFp.prototype.getA = curveFpGetA |
|||
ECCurveFp.prototype.getB = curveFpGetB |
|||
ECCurveFp.prototype.equals = curveFpEquals |
|||
ECCurveFp.prototype.getInfinity = curveFpGetInfinity |
|||
ECCurveFp.prototype.fromBigInteger = curveFpFromBigInteger |
|||
|
|||
ECFieldElementFp.prototype.getByteLength = function () { |
|||
return Math.floor((this.toBigInteger().bitLength() + 7) / 8) |
|||
} |
|||
|
|||
ECPointFp.prototype.getEncoded = function(compressed) { |
|||
var x = this.getX().toBigInteger() |
|||
var y = this.getY().toBigInteger() |
|||
var buffer |
|||
|
|||
// 0x02/0x03 | X
|
|||
if (compressed) { |
|||
buffer = new Buffer(33) |
|||
buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0) |
|||
|
|||
// 0x04 | X | Y
|
|||
} else { |
|||
buffer = new Buffer(65) |
|||
buffer.writeUInt8(0x04, 0) |
|||
|
|||
y.toBuffer(32).copy(buffer, 33) |
|||
} |
|||
|
|||
x.toBuffer(32).copy(buffer, 1) |
|||
|
|||
return buffer |
|||
} |
|||
|
|||
ECPointFp.decodeFrom = function (curve, buffer) { |
|||
var type = buffer.readUInt8(0) |
|||
var compressed = type !== 0x04 |
|||
var x = BigInteger.fromBuffer(buffer.slice(1, 33)) |
|||
var y |
|||
|
|||
if (compressed) { |
|||
assert.equal(buffer.length, 33, 'Invalid sequence length') |
|||
assert(type === 0x02 || type === 0x03, 'Invalid sequence tag') |
|||
|
|||
var isYEven = (type === 0x02) |
|||
var a = curve.getA().toBigInteger() |
|||
var b = curve.getB().toBigInteger() |
|||
var p = curve.getQ() |
|||
|
|||
// We precalculate (p + 1) / 4 where p is the field order
|
|||
if (!curve.P_OVER_FOUR) { |
|||
curve.P_OVER_FOUR = p.add(BigInteger.ONE).shiftRight(2) |
|||
} |
|||
|
|||
// Convert x to point
|
|||
var alpha = x.pow(3).add(a.multiply(x)).add(b).mod(p) |
|||
var beta = alpha.modPow(curve.P_OVER_FOUR, p) |
|||
|
|||
// If beta is even, but y isn't, or vice versa, then convert it,
|
|||
// otherwise we're done and y == beta.
|
|||
y = (beta.isEven() ^ isYEven) ? p.subtract(beta) : beta |
|||
|
|||
} else { |
|||
assert.equal(buffer.length, 65, 'Invalid sequence length') |
|||
|
|||
y = BigInteger.fromBuffer(buffer.slice(33)) |
|||
} |
|||
|
|||
var Q = new ECPointFp(curve, curve.fromBigInteger(x), curve.fromBigInteger(y)) |
|||
|
|||
return { |
|||
Q: Q, |
|||
compressed: compressed |
|||
} |
|||
} |
|||
|
|||
ECPointFp.prototype.isOnCurve = function () { |
|||
var x = this.getX().toBigInteger() |
|||
var y = this.getY().toBigInteger() |
|||
var a = this.curve.getA().toBigInteger() |
|||
var b = this.curve.getB().toBigInteger() |
|||
var p = this.curve.getQ() |
|||
var lhs = y.square().mod(p) |
|||
var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p) |
|||
return lhs.equals(rhs) |
|||
} |
|||
|
|||
ECPointFp.prototype.toString = function () { |
|||
return '('+this.getX().toBigInteger().toString()+','+ |
|||
this.getY().toBigInteger().toString()+')' |
|||
} |
|||
|
|||
/** |
|||
* Validate an elliptic curve point. |
|||
* |
|||
* See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive |
|||
*/ |
|||
ECPointFp.prototype.validate = function () { |
|||
var n = this.curve.getQ() |
|||
|
|||
// Check Q != O
|
|||
if (this.isInfinity()) { |
|||
throw new Error("Point is at infinity.") |
|||
} |
|||
|
|||
// Check coordinate bounds
|
|||
var x = this.getX().toBigInteger() |
|||
var y = this.getY().toBigInteger() |
|||
if (x.compareTo(BigInteger.ONE) < 0 || |
|||
x.compareTo(n.subtract(BigInteger.ONE)) > 0) { |
|||
throw new Error('x coordinate out of bounds') |
|||
} |
|||
if (y.compareTo(BigInteger.ONE) < 0 || |
|||
y.compareTo(n.subtract(BigInteger.ONE)) > 0) { |
|||
throw new Error('y coordinate out of bounds') |
|||
} |
|||
|
|||
// Check y^2 = x^3 + ax + b (mod n)
|
|||
if (!this.isOnCurve()) { |
|||
throw new Error("Point is not on the curve.") |
|||
} |
|||
|
|||
// Check nQ = 0 (Q is a scalar multiple of G)
|
|||
if (this.multiply(n).isInfinity()) { |
|||
// TODO: This check doesn't work - fix.
|
|||
throw new Error("Point is not a scalar multiple of G.") |
|||
} |
|||
|
|||
return true |
|||
} |
|||
|
|||
module.exports = ECCurveFp |
|||
module.exports.ECPointFp = ECPointFp |
|||
@ -1,84 +0,0 @@ |
|||
// Named EC curves
|
|||
|
|||
var BigInteger = require('bigi') |
|||
var ECCurveFp = require('./ec') |
|||
var ECPointFp = ECCurveFp.ECPointFp |
|||
|
|||
// ----------------
|
|||
// X9ECParameters
|
|||
|
|||
// constructor
|
|||
function X9ECParameters(curve,g,n,h) { |
|||
this.curve = curve |
|||
this.g = g |
|||
this.n = n |
|||
this.h = h |
|||
} |
|||
|
|||
function x9getCurve() { |
|||
return this.curve |
|||
} |
|||
|
|||
function x9getG() { |
|||
return this.g |
|||
} |
|||
|
|||
function x9getN() { |
|||
return this.n |
|||
} |
|||
|
|||
function x9getH() { |
|||
return this.h |
|||
} |
|||
|
|||
X9ECParameters.prototype.getCurve = x9getCurve |
|||
X9ECParameters.prototype.getG = x9getG |
|||
X9ECParameters.prototype.getN = x9getN |
|||
X9ECParameters.prototype.getH = x9getH |
|||
|
|||
function secp256r1() { |
|||
// p = 2^224 (2^32 - 1) + 2^192 + 2^96 - 1
|
|||
var p = BigInteger.fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF") |
|||
var a = BigInteger.fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC") |
|||
var b = BigInteger.fromHex("5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B") |
|||
//byte[] S = BigInteger.fromHex("C49D360886E704936A6678E1139D26B7819F7E90")
|
|||
var n = BigInteger.fromHex("FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551") |
|||
var h = BigInteger.ONE |
|||
var curve = new ECCurveFp(p, a, b) |
|||
|
|||
var x = BigInteger.fromHex("6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296") |
|||
var y = BigInteger.fromHex("4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5") |
|||
var G = new ECPointFp(curve, |
|||
curve.fromBigInteger(x), |
|||
curve.fromBigInteger(y)) |
|||
|
|||
return new X9ECParameters(curve, G, n, h) |
|||
} |
|||
|
|||
function secp256k1() { |
|||
// p = 2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1
|
|||
var p = BigInteger.fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F") |
|||
var a = BigInteger.ZERO |
|||
var b = BigInteger.fromHex("07") |
|||
//byte[] S = null
|
|||
var n = BigInteger.fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141") |
|||
var h = BigInteger.ONE |
|||
var curve = new ECCurveFp(p, a, b) |
|||
|
|||
var x = BigInteger.fromHex("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798") |
|||
var y = BigInteger.fromHex("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8") |
|||
var G = new ECPointFp(curve, |
|||
curve.fromBigInteger(x), |
|||
curve.fromBigInteger(y)) |
|||
|
|||
return new X9ECParameters(curve, G, n, h) |
|||
} |
|||
|
|||
function getSECCurveByName(name) { |
|||
return ({ |
|||
"secp256k1": secp256k1, |
|||
"secp256r1": secp256r1 |
|||
}[name])() |
|||
} |
|||
|
|||
module.exports = getSECCurveByName |
|||
@ -1,84 +0,0 @@ |
|||
var assert = require('assert') |
|||
|
|||
var sec = require('../src/sec') |
|||
var ecparams = sec('secp256k1') |
|||
|
|||
var BigInteger = require('bigi') |
|||
var ECPointFp = require('../src/ec').ECPointFp |
|||
|
|||
var fixtures = require('./fixtures/ec.json') |
|||
|
|||
describe('ec', function() { |
|||
describe('ECPointFp', function() { |
|||
it('behaves correctly', function() { |
|||
var G = ecparams.getG() |
|||
var n = ecparams.getN() |
|||
|
|||
assert.ok(G.multiply(n).isInfinity(), "Gn is infinite") |
|||
|
|||
var k = BigInteger.ONE |
|||
var P = G.multiply(k) |
|||
assert.ok(!P.isInfinity(), "kG is not infinite") |
|||
assert.ok(P.isOnCurve(), "kG on curve") |
|||
assert.ok(P.multiply(n).isInfinity(), "kGn is infinite") |
|||
|
|||
assert.ok(P.validate(), "kG validates as a public key") |
|||
}) |
|||
|
|||
describe('getEncoded', function() { |
|||
it('encodes a point correctly', function() { |
|||
fixtures.valid.ECPointFp.forEach(function(f) { |
|||
var curve = ecparams.getCurve() |
|||
var Q = new ECPointFp( |
|||
curve, |
|||
curve.fromBigInteger(new BigInteger(f.x)), |
|||
curve.fromBigInteger(new BigInteger(f.y)) |
|||
) |
|||
|
|||
var encoded = Q.getEncoded(f.compressed) |
|||
assert.equal(encoded.toString('hex'), f.hex) |
|||
}) |
|||
}) |
|||
}) |
|||
|
|||
describe('decodeFrom', function() { |
|||
it('decodes the correct point', function() { |
|||
fixtures.valid.ECPointFp.forEach(function(f) { |
|||
var curve = ecparams.getCurve() |
|||
var buffer = new Buffer(f.hex, 'hex') |
|||
|
|||
var decoded = ECPointFp.decodeFrom(curve, buffer) |
|||
assert.equal(decoded.Q.getX().toBigInteger().toString(), f.x) |
|||
assert.equal(decoded.Q.getY().toBigInteger().toString(), f.y) |
|||
assert.equal(decoded.compressed, f.compressed) |
|||
}) |
|||
}) |
|||
|
|||
fixtures.invalid.ECPointFp.forEach(function(f) { |
|||
it('throws on ' + f.description, function() { |
|||
var curve = ecparams.getCurve() |
|||
var buffer = new Buffer(f.hex, 'hex') |
|||
|
|||
assert.throws(function() { |
|||
ECPointFp.decodeFrom(curve, buffer) |
|||
}, /Invalid sequence length|Invalid sequence tag/) |
|||
}) |
|||
}) |
|||
|
|||
it('supports secp256r1', function() { |
|||
var f = fixtures.valid.ECPointFp[1] |
|||
var ecparams2 = sec('secp256r1') |
|||
var curve = ecparams2.getCurve() |
|||
|
|||
var d = BigInteger.ONE |
|||
var Q = ecparams2.getG().multiply(d) |
|||
|
|||
var buffer = Q.getEncoded(true) |
|||
var decoded = ECPointFp.decodeFrom(curve, buffer) |
|||
|
|||
assert(Q.equals(decoded.Q)) |
|||
assert(decoded.compressed, true) |
|||
}) |
|||
}) |
|||
}) |
|||
}) |
|||
@ -1,60 +0,0 @@ |
|||
{ |
|||
"valid": { |
|||
"ECPointFp": [ |
|||
{ |
|||
"x": "55066263022277343669578718895168534326250603453777594175500187360389116729240", |
|||
"y": "32670510020758816978083085130507043184471273380659243275938904335757337482424", |
|||
"compressed": false, |
|||
"hex": "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8" |
|||
}, |
|||
{ |
|||
"x": "55066263022277343669578718895168534326250603453777594175500187360389116729240", |
|||
"y": "32670510020758816978083085130507043184471273380659243275938904335757337482424", |
|||
"compressed": true, |
|||
"hex": "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" |
|||
}, |
|||
{ |
|||
"x": "83225686012142088543596389522774768397204444195709443235253141114409346958144", |
|||
"y": "23739058578904784236915560265041168694780215705543362357495033621678991351768", |
|||
"compressed": true, |
|||
"hex": "02b80011a883a0fd621ad46dfc405df1e74bf075cbaf700fd4aebef6e96f848340" |
|||
}, |
|||
{ |
|||
"x": "30095590000961171681152428142595206241714764354580127609094760797518133922356", |
|||
"y": "93521207164355458151597931319591130635754976513751247168472016818884561919702", |
|||
"compressed": true, |
|||
"hex": "024289801366bcee6172b771cf5a7f13aaecd237a0b9a1ff9d769cabc2e6b70a34" |
|||
}, |
|||
{ |
|||
"x": "55066263022277343669578718895168534326250603453777594175500187360389116729240", |
|||
"y": "83121579216557378445487899878180864668798711284981320763518679672151497189239", |
|||
"compressed": true, |
|||
"hex": "0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" |
|||
} |
|||
] |
|||
}, |
|||
"invalid": { |
|||
"ECPointFp": [ |
|||
{ |
|||
"description": "Invalid sequence tag", |
|||
"hex": "0179be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" |
|||
}, |
|||
{ |
|||
"description": "Sequence too short", |
|||
"hex": "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10" |
|||
}, |
|||
{ |
|||
"description": "Sequence too short (compressed)", |
|||
"hex": "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8" |
|||
}, |
|||
{ |
|||
"description": "Sequence too long", |
|||
"hex": "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b80000" |
|||
}, |
|||
{ |
|||
"description": "Sequence too long (compressed)", |
|||
"hex": "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f817980000" |
|||
} |
|||
] |
|||
} |
|||
} |
|||
Loading…
Reference in new issue