public void Equal(EllipticalCurve crv)
{
var key = ECJwk.GeneratePrivateKey(crv);
Assert.True(key.Equals(key));
Assert.Equal(key, key);
var publicKey = key.AsPublicKey();
Assert.NotEqual(key, publicKey);
var copiedKey = ECJwk.FromJson(key.ToString());
Assert.Equal(key, copiedKey);
// 'kid' is not a discriminant, excepted if the value is different.
copiedKey.Kid = default;
Assert.Equal(key, copiedKey);
Assert.Equal(copiedKey, key);
key.Kid = default;
Assert.Equal(key, copiedKey);
key.Kid = JsonEncodedText.Encode("X");
copiedKey.Kid = JsonEncodedText.Encode("Y");
Assert.NotEqual(key, copiedKey);
Assert.NotEqual(key, Jwk.None);
}
public static void SetUp()
{
CartesianCoordinate center = new CartesianCoordinate(xOffset, yOffset);
Angle rotation = Angle.Origin();
curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
}
public static void CloneCurve()
{
EllipticalCurve curveCloned = curve.CloneCurve();
Assert.AreEqual(curve.Focus, curveCloned.Focus);
Assert.AreEqual(curve.Focus2, curveCloned.Focus2);
Assert.AreEqual(curve.Directrix.ControlPointI, curveCloned.Directrix.ControlPointI);
Assert.AreEqual(curve.Directrix.ControlPointJ, curveCloned.Directrix.ControlPointJ);
Assert.AreEqual(curve.Directrix2.ControlPointI, curveCloned.Directrix2.ControlPointI);
Assert.AreEqual(curve.Directrix2.ControlPointJ, curveCloned.Directrix2.ControlPointJ);
Assert.AreEqual(curve.DistanceFromDirectrixToLocalOrigin, curveCloned.DistanceFromDirectrixToLocalOrigin, Tolerance);
Assert.AreEqual(curve.DistanceFromFocusToDirectrix, curveCloned.DistanceFromFocusToDirectrix, Tolerance);
Assert.AreEqual(curve.DistanceFromFocusToLocalOrigin, curveCloned.DistanceFromFocusToLocalOrigin, Tolerance);
Assert.AreEqual(curve.DistanceFromVertexMajorToLocalOrigin, curveCloned.DistanceFromVertexMajorToLocalOrigin, Tolerance);
Assert.AreEqual(curve.DistanceFromVertexMinorToMajorAxis, curveCloned.DistanceFromVertexMinorToMajorAxis, Tolerance);
Assert.AreEqual(curve.SemilatusRectumDistance, curveCloned.SemilatusRectumDistance, Tolerance);
Assert.AreEqual(curve.Eccentricity, curveCloned.Eccentricity, Tolerance);
Assert.AreEqual(curve.LocalOrigin, curveCloned.LocalOrigin);
Assert.AreEqual(curve.Rotation, curveCloned.Rotation);
Assert.AreEqual(curve.VerticesMajor.Item1, curveCloned.VerticesMajor.Item1);
Assert.AreEqual(curve.VerticesMajor.Item2, curveCloned.VerticesMajor.Item2);
Assert.AreEqual(curve.VerticesMinor.Item1, curveCloned.VerticesMinor.Item1);
Assert.AreEqual(curve.VerticesMinor.Item2, curveCloned.VerticesMinor.Item2);
Assert.AreEqual(curve.Range.Start.Limit, curveCloned.Range.Start.Limit);
Assert.AreEqual(curve.Range.End.Limit, curveCloned.Range.End.Limit);
}
public static void YsAtX_Out_of_Range_Return_Empty_Arrays(double xCoord, double x, double y, double rotation)
{
CartesianCoordinate center = new CartesianCoordinate(x, y);
EllipticalCurve curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
double[] yCoords = curve.YsAtX(xCoord);
Assert.AreEqual(0, yCoords.Length);
}
public static void YatX(double xCoord, double x, double y, double rotation, double yCoordExpected)
{
CartesianCoordinate center = new CartesianCoordinate(x, y);
EllipticalCurve curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
double yCoord = curve.YatX(xCoord);
Assert.AreEqual(yCoordExpected, yCoord, Tolerance);
}
public static void YatX_Out_of_Range_Return_Infinity(double xCoord, double x, double y, double rotation)
{
CartesianCoordinate center = new CartesianCoordinate(x, y);
EllipticalCurve curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
double yCoord = curve.YatX(xCoord);
Assert.AreEqual(double.PositiveInfinity, yCoord);
}
public static void Initialization_at_Local_Origin_with_Radii()
{
// Expected Complex Results
CartesianCoordinate center = CartesianCoordinate.Origin();
Angle rotation = Angle.Origin();
double a = 5;
double b = 3;
double c = (a.Squared() - b.Squared()).Sqrt();
double e = c / a;
double p = a * (1 - e.Squared());
double xe = a.Squared() / c;
CartesianCoordinate vertexMajor1 = new CartesianCoordinate(a, 0);
CartesianCoordinate vertexMajor2 = new CartesianCoordinate(-a, 0);
CartesianCoordinate vertexMinor1 = new CartesianCoordinate(0, b);
CartesianCoordinate vertexMinor2 = new CartesianCoordinate(0, -b);
CartesianCoordinate focus1 = new CartesianCoordinate(c, 0);
CartesianCoordinate focus2 = new CartesianCoordinate(-c, 0);
CartesianCoordinate directrix1I = new CartesianCoordinate(xe, 0);
CartesianCoordinate directrix1J = new CartesianCoordinate(xe, 1);
CartesianCoordinate directrix2I = new CartesianCoordinate(-xe, 0);
CartesianCoordinate directrix2J = new CartesianCoordinate(-xe, 1);
// Initialization
EllipticalCurve curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
// Simple properties
Assert.AreEqual(a, curve.DistanceFromVertexMajorToLocalOrigin, Tolerance);
Assert.AreEqual(b, curve.DistanceFromVertexMinorToMajorAxis, Tolerance);
Assert.AreEqual(c, curve.DistanceFromFocusToLocalOrigin, Tolerance);
Assert.AreEqual(e, curve.Eccentricity, Tolerance);
Assert.AreEqual(p, curve.SemilatusRectumDistance, Tolerance);
Assert.AreEqual(xe, curve.DistanceFromDirectrixToLocalOrigin, Tolerance);
Assert.AreEqual(xe - c, curve.DistanceFromFocusToDirectrix, Tolerance);
// Position properties
Assert.AreEqual(Angle.Origin(), curve.Rotation);
Assert.AreEqual(focus1, curve.Focus);
Assert.AreEqual(center, curve.LocalOrigin);
// Coordinate properties
Assert.AreEqual(vertexMajor1, curve.VerticesMajor.Item1);
Assert.AreEqual(vertexMajor2, curve.VerticesMajor.Item2);
Assert.AreEqual(vertexMinor1, curve.VerticesMinor.Item1);
Assert.AreEqual(vertexMinor2, curve.VerticesMinor.Item2);
Assert.AreEqual(vertexMajor1, curve.Range.Start.Limit);
Assert.AreEqual(vertexMajor1, curve.Range.End.Limit);
Assert.AreEqual(directrix1I, curve.Directrix.ControlPointI);
Assert.AreEqual(directrix1J, curve.Directrix.ControlPointJ);
// Complex Properties unique to Ellipse
Assert.AreEqual(focus2, curve.Focus2);
Assert.AreEqual(directrix2I, curve.Directrix2.ControlPointI);
Assert.AreEqual(directrix2J, curve.Directrix2.ControlPointJ);
}
public void GenerateKey(EllipticalCurve crv)
{
var key = ECJwk.GeneratePrivateKey(crv);
Assert.NotNull(key);
var key2 = ECJwk.GeneratePrivateKey(crv.SupportedSignatureAlgorithm);
Assert.NotNull(key2);
}
public static void XsAtY(double yCoord, double x, double y, double rotation, double x1CoordExpected, double x2CoordExpected)
{
CartesianCoordinate center = new CartesianCoordinate(x, y);
EllipticalCurve curve = new EllipticalCurve(a, b, center, rotation, Tolerance);
double[] xCoords = curve.XsAtY(yCoord);
Assert.AreEqual(x1CoordExpected, xCoords[0], Tolerance);
Assert.AreEqual(x2CoordExpected, xCoords[1], Tolerance);
}
public static void IsClosedCurve_Returns_False_When_Curve_Does_Not_Close_to_Form_a_Shape()
{
EllipticalCurve curve = new EllipticalCurve(a, b, CartesianCoordinate.Origin(), Angle.Origin(), Tolerance);
Assert.IsTrue(curve.Range.Start.Limit == curve.Range.End.Limit);
Assert.IsTrue(curve.IsClosedCurve());
// Change limits
CartesianCoordinate newRangeLimit = new CartesianCoordinate(-2, 2);
curve.Range.End.SetLimitByCoordinate(newRangeLimit);
Assert.IsFalse(curve.Range.Start.Limit == curve.Range.End.Limit);
Assert.IsFalse(curve.IsClosedCurve());
}
public void GenerateKey(EllipticalCurve crv)
{
var key = ECJwk.GeneratePrivateKey(crv);
Assert.NotNull(key);
}
protected override ECJwk GenerateKey(IConsole console)
{
ECJwk key;
var stopwatch = new Stopwatch();
if (SignatureAlgorithm.TryParse(_alg, out var signatureAlgorithm))
{
if (EllipticalCurve.TryParse(_curve, out var curve))
{
if (EllipticalCurve.TryGetSupportedCurve(signatureAlgorithm, out var curve2))
{
if (curve.Id != curve2.Id)
{
throw new InvalidOperationException($@"Unable to generate 'EC' JWK. Curve '{curve}' and algorithm '{signatureAlgorithm}' are not compatible'. Use algorithm '{curve.SupportedSignatureAlgorithm}' with curve '{curve}', or curve '{curve2}' with algorithm '{signatureAlgorithm}'.");
}
}
else
{
throw new InvalidOperationException($@"Unable to generate 'EC' JWK. Curve '{curve}' and algorithm '{signatureAlgorithm}' are not compatible'. Use algorithm '{curve.SupportedSignatureAlgorithm}' with curve '{curve}'.");
}
}
console.Verbose($@"Generating 'EC' JWK of {signatureAlgorithm.RequiredKeySizeInBits} bits for algorithm {signatureAlgorithm}...");
stopwatch.Start();
key = ECJwk.GeneratePrivateKey(signatureAlgorithm, computeThumbprint: !_noKid);
}
else if (EllipticalCurve.TryParse(_curve, out var curve))
{
if (KeyManagementAlgorithm.TryParse(_alg, out var keyManagementAlgorithm))
{
console.Verbose($@"Generating 'EC' JWK for algorithm {keyManagementAlgorithm} and curve {curve}...");
stopwatch.Start();
key = ECJwk.GeneratePrivateKey(curve, keyManagementAlgorithm, computeThumbprint: !_noKid);
}
else
{
console.Verbose($@"Generating 'EC' JWK for curve {curve}...");
stopwatch.Start();
key = ECJwk.GeneratePrivateKey(curve, computeThumbprint: !_noKid);
}
}
else
{
throw new InvalidOperationException("Unable to found the way to generate the key. Please specify a valid curve or a valid algorithm.");
}
console.Verbose($"JWK generated in {stopwatch.ElapsedMilliseconds} ms.");
if (_kid != null)
{
console.Verbose($"kid: {_kid}");
key.Kid = JsonEncodedText.Encode(_kid);
}
else if (!_noKid)
{
console.Verbose($"kid: {key.Kid}");
}
if (_use != null)
{
console.Verbose($"use: {_use}");
key.Use = JsonEncodedText.Encode(_use);
}
if (_keyOps != null && _keyOps.Count != 0)
{
console.Verbose($"key_ops: {string.Join(", ", _keyOps)}");
foreach (var keyOps in _keyOps)
{
if (keyOps != null)
{
key.KeyOps.Add(JsonEncodedText.Encode(keyOps));
}
}
}
return(key);
}
