Novacoin/CKeyPair.cs

   1 \feffusing System.Collections.Generic;
   2 using System.Linq;
   3 using System;
   4
   5 using Org.BouncyCastle.Math;
   6 using Org.BouncyCastle.Math.EC;
   7
   8 using Org.BouncyCastle.Crypto;
   9 using Org.BouncyCastle.Crypto.Generators;
  10 using Org.BouncyCastle.Crypto.Parameters;
  11 using Org.BouncyCastle.Security;
  12
  13
  14 namespace Novacoin
  15 {
  16     public class CKeyPair : CKey
  17     {
  18         private ECPrivateKeyParameters _Private;
  19
  20         /// <summary>
  21         /// Initialize new CKeyPair instance with random secret.
  22         /// </summary>
  23         public CKeyPair(bool Compressed=true)
  24         {
  25             ECKeyGenerationParameters genParams = new ECKeyGenerationParameters(domain, new SecureRandom());
  26             ECKeyPairGenerator generator = new ECKeyPairGenerator("ECDSA");
  27             generator.Init(genParams);
  28             AsymmetricCipherKeyPair ecKeyPair = generator.GenerateKeyPair();
  29
  30             _Private = (ECPrivateKeyParameters)ecKeyPair.Private;
  31             _Public = (ECPublicKeyParameters)ecKeyPair.Public;
  32
  33             if (Compressed)
  34             {
  35                 _Public = Compress(_Public);
  36             }
  37         }
  38
  39         /// <summary>
  40         /// Init key pair using secret sequence of bytes
  41         /// </summary>
  42         /// <param name="secretBytes">Byte sequence</param>
  43         /// <param name="Compressed">Compression flag</param>
  44         public CKeyPair(IEnumerable<byte> secretBytes, bool Compressed=true)
  45         {
  46             // Deserialize secret value
  47             BigInteger D = new BigInteger(secretBytes.Take(32).ToArray());
  48
  49             if (D.SignValue == -1)
  50             {
  51                 List<byte> fixedKeyBytes = secretBytes.Take(32).ToList();
  52                 fixedKeyBytes.Insert(0, 0x00); // prepend with sign byte
  53
  54                 D = new BigInteger(fixedKeyBytes.ToArray());
  55             }
  56
  57             // Calculate public key
  58             ECPoint Q = curve.G.Multiply(D);
  59
  60             _Private = new ECPrivateKeyParameters(D, domain);
  61             _Public = new ECPublicKeyParameters(Q, domain);
  62
  63             if (Compressed)
  64             {
  65                 _Public = Compress(_Public);
  66             }
  67         }
  68
  69         /// <summary>
  70         /// Init key pair using secret sequence of bytes
  71         /// </summary>
  72         /// <param name="secretBytes">Byte sequence</param>
  73         public CKeyPair(IEnumerable<byte> secretBytes) :
  74             this (secretBytes.Take(32), (secretBytes.Count() == 33 && secretBytes.Last() == 0x01))
  75         {
  76         }
  77
  78         public CKeyPair(string strBase58)
  79         {
  80             List<byte> rawBytes = AddressTools.Base58DecodeCheck(strBase58).ToList();
  81             rawBytes.RemoveAt(0); // Remove key version byte
  82
  83             // Deserialize secret value
  84             BigInteger D = new BigInteger(rawBytes.Take(32).ToArray());
  85
  86             if (D.SignValue == -1)
  87             {
  88                 List<byte> secretbytes = rawBytes.Take(32).ToList(); // Copy secret
  89                 secretbytes.Insert(0, 0x00); // Prepend with sign byte
  90
  91                 D = new BigInteger(secretbytes.ToArray()); // Try decoding again
  92             }
  93
  94             // Calculate public key
  95             ECPoint Q = curve.G.Multiply(D);
  96
  97             _Private = new ECPrivateKeyParameters(D, domain);
  98             _Public = new ECPublicKeyParameters(Q, domain);
  99
 100             if (rawBytes.Count == 33 && rawBytes.Last() == 0x01) // Check compression tag
 101             {
 102                 _Public = Compress(_Public);
 103             }
 104         }
 105
 106         /// <summary>
 107         /// Initialize a copy of CKeyPair instance
 108         /// </summary>
 109         /// <param name="pair">CKyPair instance</param>
 110         public CKeyPair(CKeyPair pair)
 111         {
 112             _Public = pair._Public;
 113             _Private = pair._Private;
 114         }
 115
 116         /// <summary>
 117         /// Create signature for supplied data
 118         /// </summary>
 119         /// <param name="data">Hash to sigh</param>
 120         /// <returns>Signature bytes sequence</returns>
 121         public IEnumerable<byte> Sign(Hash sigHash)
 122         {
 123             ISigner signer = SignerUtilities.GetSigner("NONEwithECDSA");
 124             signer.Init(true, _Private);
 125             signer.BlockUpdate(sigHash.hashBytes, 0, sigHash.hashSize);
 126
 127             return signer.GenerateSignature();
 128         }
 129
 130         public CPubKey PubKey
 131         {
 132             get { return new CPubKey(PublicBytes); }
 133         }
 134
 135         /// <summary>
 136         /// SecretBytes part of key pair
 137         /// </summary>
 138         public IEnumerable<byte> SecretBytes
 139         {
 140             get
 141             {
 142                 List<byte> secretBytes = new List<byte>(_Private.D.ToByteArray());
 143
 144                 if (secretBytes[0] == 0x00)
 145                 {
 146                     // Remove sign
 147                     secretBytes.RemoveAt(0);
 148                 }
 149
 150                 if (IsCompressed)
 151                 {
 152                     // Set compression flag
 153                     secretBytes.Add(0x01);
 154                 }
 155
 156                 return secretBytes;
 157             }
 158         }
 159
 160         public string ToHex()
 161         {
 162             return Interop.ToHex(SecretBytes);
 163         }
 164
 165         public override string ToString()
 166         {
 167             List<byte> r = new List<byte>();
 168
 169             r.Add((byte)(128 + AddrType.PUBKEY_ADDRESS)); // Key version
 170             r.AddRange(SecretBytes); // Key data
 171
 172             return AddressTools.Base58EncodeCheck(r);
 173         }
 174     }
 175 }