private ECPoint CalculatePoint(ECPublicKeyParameters pubKeyParams)
{
var dp = keyParam.Parameters;
if (!dp.Equals(pubKeyParams.Parameters))
{
throw new InvalidOperationException("ECDH public key has wrong domain parameters");
}
var d = keyParam.D;
ECPoint Q = ECAlgorithms.CleanPoint(dp.Curve, pubKeyParams.Q);
if (Q.IsInfinity)
{
throw new InvalidOperationException("Infinity is not a valid public key for ECDH");
}
BigInteger h = dp.H;
if (!h.Equals(BigInteger.One))
{
d = dp.HInv.Multiply(d).Mod(dp.N);
Q = ECAlgorithms.ReferenceMultiply(Q, h);
}
ECPoint P = Q.Multiply(d).Normalize();
if (P.IsInfinity)
{
throw new InvalidOperationException("Infinity is not a valid agreement value for ECDH");
}
return(P);
}
/**
* Checks, if the point multiplication algorithm of the given point yields
* the same result as point multiplication done by the reference
* implementation given in <code>multiply()</code>. This method chooses a
* random number by which the given point <code>p</code> is multiplied.
*
* @param p
* The point to be multiplied.
* @param numBits
* The bitlength of the random number by which <code>p</code>
* is multiplied.
*/
private void ImplTestMultiply(ECPoint p, int numBits)
{
BigInteger k = new BigInteger(numBits, secRand);
ECPoint reff = ECAlgorithms.ReferenceMultiply(p, k);
ECPoint q = p.Multiply(k);
AssertPointsEqual("ECPoint.Multiply is incorrect", reff, q);
}
protected internal bool SatisfiesCofactor()
{
BigInteger cofactor = Curve.Cofactor;
if (cofactor != null && !cofactor.Equals(BigInteger.One))
{
return(!ECAlgorithms.ReferenceMultiply(this, cofactor).IsInfinity);
}
return(true);
}
/**
* Checks, if the point multiplication algorithm of the given point yields
* the same result as point multiplication done by the reference
* implementation given in <code>multiply()</code>. This method tests
* multiplication of <code>p</code> by every number of bitlength
* <code>numBits</code> or less.
*
* @param p
* The point to be multiplied.
* @param numBits
* Try every multiplier up to this bitlength
*/
private void ImplTestMultiplyAll(ECPoint p, int numBits)
{
BigInteger bound = BigInteger.One.ShiftLeft(numBits);
BigInteger k = BigInteger.Zero;
do
{
ECPoint reff = ECAlgorithms.ReferenceMultiply(p, k);
ECPoint q = p.Multiply(k);
AssertPointsEqual("ECPoint.Multiply is incorrect", reff, q);
k = k.Add(BigInteger.One);
}while (k.CompareTo(bound) < 0);
}
private ECPoint CalculatePoint(ECPublicKeyParameters pubKeyParams)
{
ECDomainParameters dp = keyParam.Parameters;
if (!dp.Equals(pubKeyParams.Parameters))
{
throw new InvalidOperationException(
"ECDH public key has wrong domain parameters"
);
}
BigInteger d = keyParam.D;
ECPoint q = dp.Curve.DecodePoint(pubKeyParams.Q.GetEncoded(true));
if (q.IsInfinity)
{
throw new InvalidOperationException(
"Infinity is not a valid public key for ECDH"
);
}
BigInteger h = dp.H;
if (!h.Equals(BigInteger.One))
{
d = dp.H.ModInverse(dp.N).Multiply(d).Mod(dp.N);
q = ECAlgorithms.ReferenceMultiply(q, h);
}
ECPoint p = q.Multiply(d).Normalize();
if (p.IsInfinity)
{
throw new InvalidOperationException(
"Infinity is not a valid agreement value for ECDH"
);
}
return(p);
}
public virtual BigInteger CalculateAgreement(
ICipherParameters pubKey)
{
ECPublicKeyParameters pub = (ECPublicKeyParameters)pubKey;
ECDomainParameters dp = privKey.Parameters;
if (!dp.Equals(pub.Parameters))
{
throw new InvalidOperationException("ECDH public key has wrong domain parameters");
}
BigInteger d = privKey.D;
// Always perform calculations on the exact curve specified by our private key's parameters
ECPoint Q = ECAlgorithms.CleanPoint(dp.Curve, pub.Q);
if (Q.IsInfinity)
{
throw new InvalidOperationException("Infinity is not a valid public key for ECDH");
}
BigInteger h = dp.H;
if (!h.Equals(BigInteger.One))
{
d = dp.HInv.Multiply(d).Mod(dp.N);
Q = ECAlgorithms.ReferenceMultiply(Q, h);
}
ECPoint P = Q.Multiply(d).Normalize();
if (P.IsInfinity)
{
throw new InvalidOperationException("Infinity is not a valid agreement value for ECDH");
}
return(P.AffineXCoord.ToBigInteger());
}
public void TestFixedPointMultiplier()
{
FixedPointCombMultiplier M = new FixedPointCombMultiplier();
ArrayList names = new ArrayList();
CollectionUtilities.AddRange(names, ECNamedCurveTable.Names);
CollectionUtilities.AddRange(names, CustomNamedCurves.Names);
ISet uniqNames = new HashSet(names);
foreach (string name in uniqNames)
{
X9ECParameters x9A = ECNamedCurveTable.GetByName(name);
X9ECParameters x9B = CustomNamedCurves.GetByName(name);
X9ECParameters x9 = x9B != null ? x9B : x9A;
for (int i = 0; i < TestsPerCurve; ++i)
{
BigInteger k = new BigInteger(x9.N.BitLength, Random);
ECPoint pRef = ECAlgorithms.ReferenceMultiply(x9.G, k);
if (x9A != null)
{
ECPoint pA = M.Multiply(x9A.G, k);
AssertPointsEqual("Standard curve fixed-point failure", pRef, pA);
}
if (x9B != null)
{
ECPoint pB = M.Multiply(x9B.G, k);
AssertPointsEqual("Custom curve fixed-point failure", pRef, pB);
}
}
}
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
return(ECAlgorithms.ReferenceMultiply(p, k));
}