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">Data bytes sequence</param>
 120         /// <returns>Signature bytes sequence</returns>
 121         public IEnumerable<byte> Sign(IEnumerable<byte> data)
 122         {
 123             byte[] dataBytes = data.ToArray();
 124
 125             ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");
 126             signer.Init(true, _Private);
 127             signer.BlockUpdate(dataBytes, 0, dataBytes.Length);
 128
 129             return signer.GenerateSignature();
 130         }
 131
 132         public CPubKey GetPubKey()
 133         {
 134             return new CPubKey(Public);
 135         }
 136
 137         /// <summary>
 138         /// Secret part of key pair
 139         /// </summary>
 140         public IEnumerable<byte> Secret
 141         {
 142             get
 143             {
 144                 List<byte> secretBytes = new List<byte>(_Private.D.ToByteArray());
 145
 146                 if (secretBytes[0] == 0x00)
 147                 {
 148                     // Remove sign
 149                     secretBytes.RemoveAt(0);
 150                 }
 151
 152                 if (IsCompressed)
 153                 {
 154                     // Set compression flag
 155                     secretBytes.Add(0x01);
 156                 }
 157
 158                 return secretBytes;
 159             }
 160         }
 161
 162         public string ToHex()
 163         {
 164             return Interop.ToHex(Secret);
 165         }
 166
 167         public override string ToString()
 168         {
 169             List<byte> r = new List<byte>();
 170
 171             r.Add((byte)(128 + AddrType.PUBKEY_ADDRESS)); // Key version
 172             r.AddRange(Secret); // Key data
 173
 174             return AddressTools.Base58EncodeCheck(r);
 175         }
 176     }
 177 }