-\feffusing System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+\feff/**
+ * Novacoin classes library
+ * Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com)
-using Org.BouncyCastle.Math;
-using Org.BouncyCastle.Math.EC;
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
-using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
-using Org.BouncyCastle.Crypto.Parameters;
-using Org.BouncyCastle.Asn1.X9;
+using System.Security.Cryptography;
+
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Math;
using Org.BouncyCastle.Security;
-using Org.BouncyCastle.Asn1.Sec;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+using System.Diagnostics.Contracts;
namespace Novacoin
{
- public class CKeyPair
- {
- private BigInteger D;
- private ECPoint Q;
- private static X9ECParameters curve = SecNamedCurves.GetByName("secp256k1");
- private static ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed());
+ public class CKeyPair : CKey
+ {
+ private ECPrivateKeyParameters _Private;
/// <summary>
/// Initialize new CKeyPair instance with random secret.
/// </summary>
- public CKeyPair()
+ public CKeyPair(bool Compressed = true)
{
- ECKeyGenerationParameters genParams = new ECKeyGenerationParameters(domain, new SecureRandom());
-
- ECKeyPairGenerator generator = new ECKeyPairGenerator("ECDSA");
+ var genParams = new ECKeyGenerationParameters(domain, new SecureRandom());
+ var generator = new ECKeyPairGenerator("ECDSA");
generator.Init(genParams);
- AsymmetricCipherKeyPair ecKeyPair = generator.GenerateKeyPair();
+ var ecKeyPair = generator.GenerateKeyPair();
+
+ _Private = (ECPrivateKeyParameters)ecKeyPair.Private;
+ _Public = (ECPublicKeyParameters)ecKeyPair.Public;
- Q = ((ECPublicKeyParameters)ecKeyPair.Public).Q;
- D = ((ECPrivateKeyParameters)ecKeyPair.Private).D;
+ if (Compressed)
+ {
+ _Public = Compress(_Public);
+ }
}
/// <summary>
/// Init key pair using secret sequence of bytes
/// </summary>
/// <param name="secretBytes">Byte sequence</param>
- public CKeyPair(IEnumerable<byte> secretBytes)
+ /// <param name="Compressed">Compression flag</param>
+ public CKeyPair(byte[] secretBytes, bool Compressed=true)
{
- D = new BigInteger(secretBytes.ToArray());
- Q = curve.G.Multiply(D);
+ Contract.Requires<ArgumentException>(secretBytes.Length == 32, "Serialized secret key must be 32 bytes long.");
+
+ // Deserialize secret value
+ var D = new BigInteger(secretBytes);
+
+ // Append with zero byte if necessary
+ if (D.SignValue == -1)
+ {
+ var positiveKeyBytes = new byte[33];
+ Array.Copy(secretBytes, 0, positiveKeyBytes, 1, 32);
+ D = new BigInteger(positiveKeyBytes);
+ }
+
+ // Calculate public key
+ var Q = curve.G.Multiply(D);
+
+ _Private = new ECPrivateKeyParameters(D, domain);
+ _Public = new ECPublicKeyParameters(Q, domain);
+
+ if (Compressed)
+ {
+ _Public = Compress(_Public);
+ }
}
/// <summary>
- /// Create signature for supplied data
+ /// Init key pair using secret sequence of bytes
/// </summary>
- /// <param name="data">Data bytes sequence</param>
- /// <returns>Signature bytes sequence</returns>
- public IEnumerable<byte> Sign(IEnumerable<byte> data)
+ /// <param name="secretBytes">Byte sequence</param>
+ public CKeyPair(byte[] secretBytes) :
+ this (secretBytes.Take(32).ToArray(), (secretBytes.Count() == 33 && secretBytes.Last() == 0x01))
{
- byte[] dataBytes = data.ToArray();
-
- ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");
- ECPrivateKeyParameters keyParameters = new ECPrivateKeyParameters(D, domain);
- signer.Init(true, keyParameters);
- signer.BlockUpdate(dataBytes, 0, dataBytes.Length);
-
- return signer.GenerateSignature();
}
- public bool Verify(IEnumerable<byte> data, IEnumerable<byte> signature)
+ public CKeyPair(string strBase58)
{
- byte[] dataBytes = data.ToArray();
+ var rawSecretBytes = AddressTools.Base58DecodeCheck(strBase58);
+
+ if (rawSecretBytes.Length != 33 && rawSecretBytes.Length != 34)
+ {
+ throw new ArgumentException("Though you have provided a correct Base58 representation of some data, this data doesn't represent a valid private key.");
+ }
+
+ // Deserialize secret value
+ var D = new BigInteger(rawSecretBytes.Skip(1).Take(32).ToArray());
+
+ if (D.SignValue == -1)
+ {
+ var secretBytes = new byte[33];
+ Array.Copy(rawSecretBytes, 1, secretBytes, 1, 32); // Copying the privkey, 32 bytes starting from second byte of array
- ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");
- ECPublicKeyParameters keyParameters = new ECPublicKeyParameters(Q, domain);
- signer.Init(false, keyParameters);
- signer.BlockUpdate(dataBytes, 0, dataBytes.Length);
+ D = new BigInteger(secretBytes); // Try decoding again
+ }
- return signer.VerifySignature(signature.ToArray());
+ // Calculate public key
+ var Q = curve.G.Multiply(D);
+
+ _Private = new ECPrivateKeyParameters(D, domain);
+ _Public = new ECPublicKeyParameters(Q, domain);
+
+ if (rawSecretBytes.Length == 34 && rawSecretBytes.Last() == 0x01) // Check compression tag
+ {
+ _Public = Compress(_Public);
+ }
}
/// <summary>
- /// Secret part of key pair
+ /// Initialize a copy of CKeyPair instance
/// </summary>
- public IEnumerable<byte> Secret
+ /// <param name="pair">CKyPair instance</param>
+ public CKeyPair(CKeyPair pair)
+ {
+ _Public = pair._Public;
+ _Private = pair._Private;
+ }
+
+ /// <summary>
+ /// Create signature for supplied data
+ /// </summary>
+ /// <param name="data">Hash to sigh</param>
+ /// <returns>Signature bytes sequence</returns>
+ public byte[] Sign(Hash sigHash)
{
- get { return D.ToByteArray(); }
+ var signer = SignerUtilities.GetSigner("NONEwithECDSA");
+ signer.Init(true, _Private);
+ signer.BlockUpdate(sigHash, 0, sigHash.hashSize);
+
+ return signer.GenerateSignature();
+ }
+
+ public CPubKey PubKey
+ {
+ get { return new CPubKey(_Public.Q.GetEncoded()); }
}
/// <summary>
- /// Public part of key pair
+ /// SecretBytes part of key pair
/// </summary>
- public IEnumerable<byte> Public
+ public static implicit operator byte[] (CKeyPair kp)
{
- get { return Q.GetEncoded(); }
+ var secretBytes = new List<byte>(kp._Private.D.ToByteArray());
+
+ if (secretBytes.Count == 33 && secretBytes[0] == 0x00)
+ {
+ // Remove sign
+ secretBytes.RemoveAt(0);
+ }
+
+ if (kp.IsCompressed)
+ {
+ // Set compression flag
+ secretBytes.Add(0x01);
+ }
+
+ return secretBytes.ToArray();
+ }
+
+ public string ToHex()
+ {
+ return Interop.ToHex((byte[])this);
}
+ /// <summary>
+ /// Generate Base58 string in wallet import format
+ /// </summary>
+ /// <returns></returns>
public override string ToString()
{
- StringBuilder sb = new StringBuilder();
+ var r = new List<byte>();
- sb.AppendFormat("CKeyPair(Secret={0}, Public={1})", Interop.ToHex(Secret), Interop.ToHex(Public));
+ r.Add((byte)(128 + AddrType.PUBKEY_ADDRESS)); // Key version
+ r.AddRange((byte[])this); // Key data
- return sb.ToString();
+ return AddressTools.Base58EncodeCheck(r.ToArray());
}
}
}