/// <summary>
/// Creates elliptic curve domain parameters based on the
/// specified values. </summary>
/// <param name="curve"> the elliptic curve which this parameter
/// defines. </param>
/// <param name="g"> the generator which is also known as the base point. </param>
/// <param name="n"> the order of the generator {@code g}. </param>
/// <param name="h"> the cofactor. </param>
/// <exception cref="NullPointerException"> if {@code curve},
/// {@code g}, or {@code n} is null. </exception>
/// <exception cref="IllegalArgumentException"> if {@code n}
/// or {@code h} is not positive. </exception>
public ECParameterSpec(EllipticCurve curve, ECPoint g, System.Numerics.BigInteger n, int h)
{
if (curve == null)
{
throw new NullPointerException("curve is null");
}
if (g == null)
{
throw new NullPointerException("g is null");
}
if (n == null)
{
throw new NullPointerException("n is null");
}
if (n.signum() != 1)
{
throw new IllegalArgumentException("n is not positive");
}
if (h <= 0)
{
throw new IllegalArgumentException("h is not positive");
}
this.Curve_Renamed = curve;
this.g = g;
this.n = n;
this.h = h;
}
public MainPage()
{
InitializeComponent();
menuPage = menu_page;
Detail.BackgroundColor = (Color)Application.Current.Resources["PageWrapperColor"];
MasterBehavior = MasterBehavior.Popover;
using (var con = DependencyService.Get <IDatabase>().GetConnection(ConnectionType.Login))
{
if (con.Table <User>().FirstOrDefault(each => each.LoggedIn) is User loggedUser)
{
EllipticCurve elliptic = new EllipticCurve(false);
Task.Run(() => elliptic.KeyExchange(loggedUser.Username)).Wait();
if (elliptic.IsSucceeded)
{
Utility.User = loggedUser;
Utility.SharedSecret = elliptic.SharedSecret;
var homePageKey = (int)MenuItemType.Home;
if (!MenuPages.ContainsKey(homePageKey))
{
MenuPages.Add(homePageKey, new NavigationPage(new HomePage()));
}
Detail = MenuPages[homePageKey];
IsGestureEnabled = true;
}
}
else
{
IsGestureEnabled = false;
}
}
var staticClassInitiation = Utility.BaseURL;
}
public void InitialiseCurve()
{
BigInt p = new BigInt("bffffffffffffffffffffffffffcffff3", 16);
Fp field = new Fp(p);
curve = new EllipticCurve(field, BigInt.ZERO, BigInt.ONE);
}
public static Point HashToPoint(byte[] toHash, EllipticCurve ec, BigInt cofactor)
{
Point P = HashToPoint(toHash, ec);
P = ec.Multiply(P, cofactor);
return(P);
}
public void IsOnCurve_PointOnCurve_True()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(19, 0);
Assert.IsTrue(ECC.IsPointOnCurve(P));
}
public void AddPoints_SamePointOnCurve_InfResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(19, 0);
Assert.IsNull(ECC.AddPoints(P, P));
}
/// <summary>
/// 使用私钥对消息进行签名
/// </summary>
/// <param name="privateKey"></param>
/// <param name="message"></param>
/// <returns></returns>
unsafe public static Signature Sign(ReadOnlySpan <byte> privateKey, ReadOnlySpan <byte> message)
{
if (privateKey.Length != 32)
{
throw new InvalidPrivateKeyException("私钥长度必须是32字节");
}
if (message.Length != 32)
{
throw new InvalidMessageException("消息长度必须是32字节");
}
var dA = new U256N(privateKey);
var msg = new U256N(message);
Span <byte> tempPrivateKey = stackalloc byte[32];
CreatePrivateKey(tempPrivateKey);
var k = new U256N(tempPrivateKey);
var p = (Point)EllipticCurve.MulG(k);
U256N R = p.X.Value;
U256N S = (msg + dA * R) / k;
if (p.Y.Value.v0 % 2 != 0)
{
S = -S;
}
return(new Signature(R, S));
}
public void VerifyCert(StringBuilder sb, BackgroundWorker bw, Certificate cert)
{
BigInteger[] args = null;
ECPoint point = ECPoint.POINT_INFINITY;
ECPoint P = ECPoint.POINT_INFINITY;
EllipticCurve curve = null;
while ((args = cert.Read()) != null)
{
if (bw.CancellationPending)
{
return;
}
curve = new EllipticCurve(args[0], args[1], args[2], args[3]);
sb.AppendFormat("N = {0}\n", args[2].ToString());
sb.AppendFormat("a = {0}", args[0].ToString());
sb.AppendLine();
sb.AppendFormat("b = {0}", args[1].ToString());
sb.AppendLine();
sb.AppendFormat("m = {0}", args[3].ToString());
sb.AppendLine();
sb.AppendFormat("q = {0}", args[4].ToString());
sb.AppendLine();
point = new ECPoint(args[5], args[6]);
sb.AppendFormat("P = ({0}, {1})", point.GetAffineX().ToString(), point.GetAffineY().ToString());
sb.AppendLine();
P = ECMath.Multiply(curve, args[3] / args[4], point);
sb.AppendFormat("Q = ({0}, {1})", P.GetAffineX().ToString(), P.GetAffineY().ToString());
sb.AppendLine();
P = ECMath.Multiply(curve, args[4], P);
sb.Append("R = (0, 1)\n");
sb.AppendLine();
}
}
public EllipticDiffieHellman(EllipticCurve curve, Point generator, BigInteger order, byte[] priv = null)
{
this.curve = curve;
this.generator = generator;
// Generate private key
if (priv == null)
{
byte[] max = order.ToByteArray();
do
{
byte[] p1 = new byte[5 /*rand.Next(max.Length) + 1*/];
rand.NextBytes(p1);
if (p1.Length == max.Length)
{
p1[p1.Length - 1] %= max[max.Length - 1];
}
else
{
p1[p1.Length - 1] &= 127;
}
this.priv = new BigInteger(p1);
} while (this.priv < 2);
}
else
{
this.priv = new BigInteger(priv);
}
// Generate public key
pub = curve.Multiply(generator, this.priv);
}
public void GelfodMethod_MainTest()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Console.WriteLine($"{ECC}, N = {ECC.N}, p = {ECC.p}");
Point Q = new Point(34, 16);
Console.WriteLine($"Q = {Q}");
Point P = new Point(69, 40);
Console.WriteLine($"P = {P}");
Dictionary <int, int> divisors = new Dictionary <int, int>
{
{ 2, 1 },
{ 3, 2 },
{ 5, 1 }
};
int expected = 34;
int actual = GelfondMethod.GetLog(ECC, Q, P, divisors);
Console.WriteLine($"l = {actual}(mod {ECC.N})");
Assert.AreEqual(expected, actual);
}
public SessionService(ApplicationContext context, IServerKeyManager keyManager, IMapper mapper, EllipticCurve ellipticCurve)
{
this.context = context;
this.keyManager = keyManager;
this.mapper = mapper;
this.ellipticCurve = ellipticCurve;
}
public Wallet()
{
this.Balance = Constants.STARTING_BALANCE;
this.KeyPair = EllipticCurve.GenerateKeys();
this.PublicKey = this.KeyPair.PublicKey();
}
/// <summary>
/// Abstract base class for Elliptic Curve / AES-256 hybrid ciphers.s
/// </summary>
/// <param name="PublicKey">Remote public key.</param>
/// <param name="ReferenceCurve">Reference curve</param>
/// <param name="DefaultSymmetricCipher">Default symmetric cipher.</param>
public EllipticCurveEndpoint(byte[] PublicKey, EllipticCurve ReferenceCurve, IE2eSymmetricCipher DefaultSymmetricCipher)
: base(DefaultSymmetricCipher)
{
this.publicKey = PublicKey;
this.curve = ReferenceCurve;
this.hasPrivateKey = false;
this.publicKeyBase64 = Convert.ToBase64String(this.publicKey);
}
/// <summary>
/// Abstract base class for Elliptic Curve / AES-256 hybrid ciphers.s
/// </summary>
/// <param name="Curve">Curve instance</param>
/// <param name="DefaultSymmetricCipher">Default symmetric cipher.</param>
public EllipticCurveEndpoint(EllipticCurve Curve, IE2eSymmetricCipher DefaultSymmetricCipher)
: base(DefaultSymmetricCipher)
{
this.curve = Curve;
this.publicKey = Curve.PublicKey;
this.hasPrivateKey = true;
this.publicKeyBase64 = Convert.ToBase64String(this.publicKey);
}
public static BigInteger computeZ(byte[] bytes, EllipticCurve theCurve)
{
BitArray hashBitArray = new BitArray(bytes);
hashBitArray.RightShift(hashBitArray.Length - DummyProject.Common.BitOperations.getBits(theCurve.p).Length);
hashBitArray.CopyTo(bytes, 0);
return(new BigInteger(bytes));
}
private static void PrintPoints(EllipticCurve curve)
{
Console.WriteLine($"Curve: {curve}");
Console.WriteLine($"Curve's order: {curve.N}{Environment.NewLine}");
Console.WriteLine("Points of curve:");
foreach (var point in curve.GenerateAllPoints())
{
Console.WriteLine(point);
}
}
public void MultiplyPoint_PointOnCurve_CorrectResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(34, 16);
Point expected = new Point(19, 0);
Point actual = ECC.MultiplyPoint(45, P);
Assert.AreEqual(expected, actual);
}
//step 3
private static BigInteger computeK(EllipticCurve theCurve)
{
BigInteger k = PrivateKeyGenerator.generatePrivateKey();
while (k >= theCurve.p)
{
k = PrivateKeyGenerator.generatePrivateKey();
}
return(k);
}
public void AddPoints_SamePointOnCurve_CorrectResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(22, 3);
Point expected = new Point(10, 90);
Point actual = ECC.AddPoints(P, P);
Assert.AreEqual(expected, actual);
}
public void NegativePoint_PointOnCurve_CorrectResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(10, 7);
Point expected = new Point(10, 90);
Point actual = ECC.GetNegativePoint(P);
Assert.AreEqual(expected, actual);
}
public BFUserPrivateKey(SerializedPrivateKey key)
{
this.key = new Point(new BigInt(key.KeyX), new BigInt(key.KeyY));
Fp field = new Fp(new BigInt(key.CurveField));
EllipticCurve curve = new EllipticCurve(field, new BigInt(key.CurveA), new BigInt(key.CurveB));
Pairing e = new TatePairing(curve, new BigInt(key.PairingGroupOrder), new BigInt(key.PairingCofactor));
Point p = new Point(new BigInt(key.PX), new BigInt(key.PY));
Point pPub = new Point(new BigInt(key.PPubX), new BigInt(key.PPubY));
this.param = new BFMasterPublicKey(e, p, pPub);
}
public void GetLog_PointOnCurve_CorrectResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(72, 48);
Point Q = new Point(72, 49);
int expected = 2; //89
int actual = ECC.GetLog(P, Q);
Assert.AreEqual(expected, actual);
}
public void GetLog_InfPoint_ReturnsCorrectResult()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = null;
Point Q = new Point(19, 0);
int expected = 2;
int actual = ECC.GetLog(P, Q);
Assert.AreEqual(expected, actual);
}
public void GetLog_SamePointsOnCurve_ReturnsOne()
{
EllipticCurve ECC = new EllipticCurve(1, 9, pField: 97, groupOrder: 90);
Point P = new Point(72, 49);
Point Q = new Point(72, 49);
int expected = 1;
int actual = ECC.GetLog(P, Q);
Assert.AreEqual(expected, actual);
}
public void TestMultBook()
{
EllipticCurve curve = new EllipticCurve(a: -1, b: 3231, modulus: 661643);
Point q = (87, 2);
q = curve.Multiply(BigInteger.Pow(2, 9), q);
bool success = q.Equals((Point)(196083, 134895));
q = curve.Multiply(BigInteger.Pow(3, 6), q);
success = success && q.Equals((Point)(470021, 282574));
Assert.IsTrue(success);
}
public static Point HashToPoint(byte[] toHash, EllipticCurve ec)
{
BigInt b = HashToField(toHash, ec.Field);
Point P = ec.GetPoint(b);
while (P == null)
{
b = b.Add(BigInt.ONE);
P = ec.GetPoint(b);
}
return(P);
}
void Output(BigInteger privateKey)
{
BigInteger publicKeyX;
BigInteger publicKeyY;
BouncyCastle.ECPrivateKeyToPublicKey(privateKey, out publicKeyX, out publicKeyY);
byte[] publicKey = EllipticCurve.PublicKeyToBytes(publicKeyX, publicKeyY);
byte[] address = ETHAddress.PublicKeyToETHAddress(publicKey);
m_paragraphAddress.Inlines.Add("Private key (confidential): 0x" + Encode.BytesToHex(Encode.BigIntegerToBytes(privateKey, 32)) + "\n");
m_paragraphAddress.Inlines.Add("Public key: 0x" + Encode.BytesToHex(publicKey) + "\n");
m_paragraphAddress.Inlines.Add("ETH address: 0x" + Encode.BytesToHex(address) + "\n");
m_paragraphAddress.Inlines.Add("ETC address: 0x" + Encode.BytesToHex(address) + "\n");
}
/// <summary>
/// 使用公钥验证消息的签名是否正确
/// </summary>
/// <param name="publicKey"></param>
/// <param name="message"></param>
/// <param name="signature"></param>
/// <returns></returns>
public static bool Verify(PublicKey publicKey, ReadOnlySpan <byte> message, Signature signature)
{
if (message.Length != 32)
{
throw new InvalidMessageException("消息长度必须是32字节");
}
var msg = new U256N(message);
var S_inv = ~(U256N)signature.S;
var u1 = S_inv * msg;
var u2 = S_inv * signature.R;
var P = EllipticCurve.MulG(u1) + new JacobianPoint(publicKey.X, publicKey.Y) * u2;
return(P.X == signature.R * (P.Z ^ 2));
}
/// <summary>
/// Compares this elliptic curve for equality with the
/// specified object. </summary>
/// <param name="obj"> the object to be compared. </param>
/// <returns> true if {@code obj} is an instance of
/// EllipticCurve and the field, A, and B match, false otherwise. </returns>
public override bool Equals(Object obj)
{
if (this == obj)
{
return(true);
}
if (obj is EllipticCurve)
{
EllipticCurve curve = (EllipticCurve)obj;
if ((Field_Renamed.Equals(curve.Field_Renamed)) && (a.Equals(curve.a)) && (b.Equals(curve.b)))
{
return(true);
}
}
return(false);
}
public static bool Validate(Transaction transaction)
{
var outputTotal = transaction.OutputMap.Values.Sum();
if (transaction.Input.Amount != outputTotal)
{
Logger.Info($"Invalid transaction from {transaction.Input.Address}");
return(false);
}
if (!EllipticCurve.VerifySignature(publicKey: transaction.Input.Address, data: transaction.OutputMap.SerializeObject(), signature: transaction.Input.Signature))
{
Logger.Info($"Invalid signature from {transaction.Input.Address}");
return(false);
}
return(true);
}
