Remove senseless comparison.
[novacoin.git] / src / key.cpp
1 // Copyright (c) 2009-2012 The Bitcoin developers
2 // Distributed under the MIT/X11 software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5 #include <map>
6
7 #include <openssl/ecdsa.h>
8 #include <openssl/evp.h>
9 #include <openssl/obj_mac.h>
10
11 #include "key.h"
12 #include "base58.h"
13
14 // Generate a private key from just the secret parameter
15 int EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key)
16 {
17     int ok = 0;
18     BN_CTX *ctx = NULL;
19     EC_POINT *pub_key = NULL;
20
21     if (!eckey) return 0;
22
23     const EC_GROUP *group = EC_KEY_get0_group(eckey);
24
25     if ((ctx = BN_CTX_new()) == NULL)
26         goto err;
27
28     pub_key = EC_POINT_new(group);
29
30     if (pub_key == NULL)
31         goto err;
32
33     if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
34         goto err;
35
36     EC_KEY_set_private_key(eckey,priv_key);
37     EC_KEY_set_public_key(eckey,pub_key);
38
39     ok = 1;
40
41 err:
42
43     if (pub_key)
44         EC_POINT_free(pub_key);
45     if (ctx != NULL)
46         BN_CTX_free(ctx);
47
48     return(ok);
49 }
50
51 // Perform ECDSA key recovery (see SEC1 4.1.6) for curves over (mod p)-fields
52 // recid selects which key is recovered
53 // if check is non-zero, additional checks are performed
54 int ECDSA_SIG_recover_key_GFp(EC_KEY *eckey, ECDSA_SIG *ecsig, const unsigned char *msg, int msglen, int recid, int check)
55 {
56     if (!eckey) return 0;
57
58     int ret = 0;
59     BN_CTX *ctx = NULL;
60
61     BIGNUM *x = NULL;
62     BIGNUM *e = NULL;
63     BIGNUM *order = NULL;
64     BIGNUM *sor = NULL;
65     BIGNUM *eor = NULL;
66     BIGNUM *field = NULL;
67     EC_POINT *R = NULL;
68     EC_POINT *O = NULL;
69     EC_POINT *Q = NULL;
70     BIGNUM *rr = NULL;
71     BIGNUM *zero = NULL;
72     int n = 0;
73     int i = recid / 2;
74
75     const EC_GROUP *group = EC_KEY_get0_group(eckey);
76     if ((ctx = BN_CTX_new()) == NULL) { ret = -1; goto err; }
77     BN_CTX_start(ctx);
78     order = BN_CTX_get(ctx);
79     if (!EC_GROUP_get_order(group, order, ctx)) { ret = -2; goto err; }
80     x = BN_CTX_get(ctx);
81     if (!BN_copy(x, order)) { ret=-1; goto err; }
82     if (!BN_mul_word(x, i)) { ret=-1; goto err; }
83     if (!BN_add(x, x, ecsig->r)) { ret=-1; goto err; }
84     field = BN_CTX_get(ctx);
85     if (!EC_GROUP_get_curve_GFp(group, field, NULL, NULL, ctx)) { ret=-2; goto err; }
86     if (BN_cmp(x, field) >= 0) { ret=0; goto err; }
87     if ((R = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
88     if (!EC_POINT_set_compressed_coordinates_GFp(group, R, x, recid % 2, ctx)) { ret=0; goto err; }
89     if (check)
90     {
91         if ((O = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
92         if (!EC_POINT_mul(group, O, NULL, R, order, ctx)) { ret=-2; goto err; }
93         if (!EC_POINT_is_at_infinity(group, O)) { ret = 0; goto err; }
94     }
95     if ((Q = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
96     n = EC_GROUP_get_degree(group);
97     e = BN_CTX_get(ctx);
98     if (!BN_bin2bn(msg, msglen, e)) { ret=-1; goto err; }
99     if (8*msglen > n) BN_rshift(e, e, 8-(n & 7));
100     zero = BN_CTX_get(ctx);
101     if (!BN_zero(zero)) { ret=-1; goto err; }
102     if (!BN_mod_sub(e, zero, e, order, ctx)) { ret=-1; goto err; }
103     rr = BN_CTX_get(ctx);
104     if (!BN_mod_inverse(rr, ecsig->r, order, ctx)) { ret=-1; goto err; }
105     sor = BN_CTX_get(ctx);
106     if (!BN_mod_mul(sor, ecsig->s, rr, order, ctx)) { ret=-1; goto err; }
107     eor = BN_CTX_get(ctx);
108     if (!BN_mod_mul(eor, e, rr, order, ctx)) { ret=-1; goto err; }
109     if (!EC_POINT_mul(group, Q, eor, R, sor, ctx)) { ret=-2; goto err; }
110     if (!EC_KEY_set_public_key(eckey, Q)) { ret=-2; goto err; }
111
112     ret = 1;
113
114 err:
115     if (ctx) {
116         BN_CTX_end(ctx);
117         BN_CTX_free(ctx);
118     }
119     if (R != NULL) EC_POINT_free(R);
120     if (O != NULL) EC_POINT_free(O);
121     if (Q != NULL) EC_POINT_free(Q);
122     return ret;
123 }
124
125 int CompareBigEndian(const unsigned char *c1, size_t c1len, const unsigned char *c2, size_t c2len) {
126     while (c1len > c2len) {
127         if (*c1)
128             return 1;
129         c1++;
130         c1len--;
131     }
132     while (c2len > c1len) {
133         if (*c2)
134             return -1;
135         c2++;
136         c2len--;
137     }
138     while (c1len > 0) {
139         if (*c1 > *c2)
140             return 1;
141         if (*c2 > *c1)
142             return -1;
143         c1++;
144         c2++;
145         c1len--;
146     }
147     return 0;
148 }
149
150 // Order of secp256k1's generator minus 1.
151 const unsigned char vchMaxModOrder[32] = {
152     0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
153     0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
154     0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
155     0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x40
156 };
157
158 // Half of the order of secp256k1's generator minus 1.
159 const unsigned char vchMaxModHalfOrder[32] = {
160     0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
161     0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
162     0x5D,0x57,0x6E,0x73,0x57,0xA4,0x50,0x1D,
163     0xDF,0xE9,0x2F,0x46,0x68,0x1B,0x20,0xA0
164 };
165
166 const unsigned char *vchZero = NULL;
167
168 void CKey::SetCompressedPubKey()
169 {
170     EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
171     fCompressedPubKey = true;
172 }
173
174 void CKey::Reset()
175 {
176     fCompressedPubKey = fSet = false;
177     if (pkey != NULL)
178         EC_KEY_free(pkey);
179     pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
180     if (pkey == NULL)
181         throw key_error("CKey::CKey() : EC_KEY_new_by_curve_name failed");
182 }
183
184 CKey::CKey()
185 {
186     pkey = NULL;
187     Reset();
188 }
189
190 CKey::CKey(const CKey& b)
191 {
192     pkey = EC_KEY_dup(b.pkey);
193     if (pkey == NULL)
194         throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
195     fSet = b.fSet;
196     fCompressedPubKey = b.fCompressedPubKey;
197 }
198
199 CKey::CKey(const CSecret& b, bool fCompressed)
200 {
201     pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
202     if (pkey == NULL)
203         throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
204     SetSecret(b, fCompressed);
205 }
206
207 CKey& CKey::operator=(const CKey& b)
208 {
209     if (!EC_KEY_copy(pkey, b.pkey))
210         throw key_error("CKey::operator=(const CKey&) : EC_KEY_copy failed");
211     fSet = b.fSet;
212     fCompressedPubKey = b.fCompressedPubKey;
213     return (*this);
214 }
215
216 CKey::~CKey()
217 {
218     if (pkey != NULL)
219         EC_KEY_free(pkey);
220 }
221
222 bool CKey::IsNull() const
223 {
224     return !fSet;
225 }
226
227 bool CKey::IsCompressed() const
228 {
229     return fCompressedPubKey;
230 }
231
232 bool CKey::CheckSignatureElement(const unsigned char *vch, int len, bool half) {
233     return CompareBigEndian(vch, len, vchZero, 0) > 0 &&
234         CompareBigEndian(vch, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0;
235 }
236
237 bool CPubKey::ReserealizeSignature(std::vector<unsigned char>& vchSig)
238 {
239     if (vchSig.empty())
240         return false;
241
242     unsigned char *pos = &vchSig[0];
243     ECDSA_SIG *sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&pos, vchSig.size());
244     if (sig == NULL)
245         return false;
246
247     bool ret = false;
248     int nSize = i2d_ECDSA_SIG(sig, NULL);
249     if (nSize > 0) {
250         vchSig.resize(nSize); // grow or shrink as needed
251
252         pos = &vchSig[0];
253         i2d_ECDSA_SIG(sig, &pos);
254
255         ret = true;
256     }
257
258     ECDSA_SIG_free(sig);
259
260     return ret;
261 }
262
263 void CKey::MakeNewKey(bool fCompressed)
264 {
265     if (!EC_KEY_generate_key(pkey))
266         throw key_error("CKey::MakeNewKey() : EC_KEY_generate_key failed");
267     if (fCompressed)
268         SetCompressedPubKey();
269     fSet = true;
270 }
271
272 bool CKey::SetPrivKey(const CPrivKey& vchPrivKey)
273 {
274     const unsigned char* pbegin = &vchPrivKey[0];
275     if (d2i_ECPrivateKey(&pkey, &pbegin, vchPrivKey.size()))
276     {
277         // In testing, d2i_ECPrivateKey can return true
278         // but fill in pkey with a key that fails
279         // EC_KEY_check_key, so:
280         if (EC_KEY_check_key(pkey))
281         {
282             fSet = true;
283             return true;
284         }
285     }
286     // If vchPrivKey data is bad d2i_ECPrivateKey() can
287     // leave pkey in a state where calling EC_KEY_free()
288     // crashes. To avoid that, set pkey to NULL and
289     // leak the memory (a leak is better than a crash)
290     pkey = NULL;
291     Reset();
292     return false;
293 }
294
295 bool CKey::SetSecret(const CSecret& vchSecret, bool fCompressed)
296 {
297     EC_KEY_free(pkey);
298     pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
299     if (pkey == NULL)
300         throw key_error("CKey::SetSecret() : EC_KEY_new_by_curve_name failed");
301
302     if (vchSecret.size() != 32)
303         throw key_error("CKey::SetSecret() : secret must be 32 bytes");
304     BIGNUM *bn = BN_bin2bn(&vchSecret[0],32,BN_new());
305     if (bn == NULL)
306         throw key_error("CKey::SetSecret() : BN_bin2bn failed");
307     if (!EC_KEY_regenerate_key(pkey,bn))
308     {
309         BN_clear_free(bn);
310         throw key_error("CKey::SetSecret() : EC_KEY_regenerate_key failed");
311     }
312     BN_clear_free(bn);
313     fSet = true;
314     if (fCompressed || fCompressedPubKey)
315         SetCompressedPubKey();
316     return true;
317 }
318
319 CSecret CKey::GetSecret(bool &fCompressed) const
320 {
321     CSecret vchRet;
322     vchRet.resize(32);
323     const BIGNUM *bn = EC_KEY_get0_private_key(pkey);
324     int nBytes = BN_num_bytes(bn);
325     if (bn == NULL)
326         throw key_error("CKey::GetSecret() : EC_KEY_get0_private_key failed");
327     int n=BN_bn2bin(bn,&vchRet[32 - nBytes]);
328     if (n != nBytes)
329         throw key_error("CKey::GetSecret(): BN_bn2bin failed");
330     fCompressed = fCompressedPubKey;
331     return vchRet;
332 }
333
334 bool CKey::WritePEM(BIO *streamObj, const SecureString &strPassKey) const // dumppem 4KJLA99FyqMMhjjDe7KnRXK4sjtv9cCtNS /tmp/test.pem 123
335 {
336     EVP_PKEY *evpKey = EVP_PKEY_new();
337     bool result = true;
338
339     do
340     {
341         if (!EVP_PKEY_assign_EC_KEY(evpKey, pkey))
342         {
343             result = error("CKey::WritePEM() : Error initializing EVP_PKEY instance.");
344             break;
345         }
346
347         if(!PEM_write_bio_PKCS8PrivateKey(streamObj, evpKey, EVP_aes_256_cbc(), (char *)&strPassKey[0], strPassKey.size(), NULL, NULL))
348         {
349             result = error("CKey::WritePEM() : Error writing private key data to stream object");
350             break;
351         }
352
353         if(!PEM_write_bio_PUBKEY(streamObj, evpKey))
354         {
355             result = error("CKey::WritePEM() : Error writing public key data to stream object");
356             break;
357         }
358     }
359     while(false);
360
361     EVP_PKEY_free(evpKey);
362     return result;
363 }
364
365 CSecret CKey::GetSecret() const
366 {
367     bool fCompressed;
368     return GetSecret(fCompressed);
369 }
370
371 CPrivKey CKey::GetPrivKey() const
372 {
373     int nSize = i2d_ECPrivateKey(pkey, NULL);
374     if (!nSize)
375         throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey failed");
376     CPrivKey vchPrivKey(nSize, 0);
377     unsigned char* pbegin = &vchPrivKey[0];
378     if (i2d_ECPrivateKey(pkey, &pbegin) != nSize)
379         throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey returned unexpected size");
380     return vchPrivKey;
381 }
382
383 CPubKey CKey::GetPubKey() const
384 {
385     int nSize = i2o_ECPublicKey(pkey, NULL);
386     if (!nSize)
387         throw key_error("CKey::GetPubKey() : i2o_ECPublicKey failed");
388     std::vector<unsigned char> vchPubKey(nSize, 0);
389     unsigned char* pbegin = &vchPubKey[0];
390     if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
391         throw key_error("CKey::GetPubKey() : i2o_ECPublicKey returned unexpected size");
392     return CPubKey(vchPubKey);
393 }
394
395 bool CKey::Sign(uint256 hash, std::vector<unsigned char>& vchSig)
396 {
397     vchSig.clear();
398     ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
399     if (sig==NULL)
400         return false;
401     const EC_GROUP *group = EC_KEY_get0_group(pkey);
402     CBigNum order, halforder;
403     EC_GROUP_get_order(group, &order, NULL);
404     BN_rshift1(&halforder, &order);
405     // enforce low S values, by negating the value (modulo the order) if above order/2.
406     if (BN_cmp(sig->s, &halforder) > 0) {
407         BN_sub(sig->s, &order, sig->s);
408     }
409     unsigned int nSize = ECDSA_size(pkey);
410     vchSig.resize(nSize); // Make sure it is big enough
411     unsigned char *pos = &vchSig[0];
412     nSize = i2d_ECDSA_SIG(sig, &pos);
413     ECDSA_SIG_free(sig);
414     vchSig.resize(nSize); // Shrink to fit actual size
415     // Testing our new signature
416     if (ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), &vchSig[0], vchSig.size(), pkey) != 1) {
417         vchSig.clear();
418         return false;
419     }
420     return true;
421 }
422
423 // create a compact signature (65 bytes), which allows reconstructing the used public key
424 // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
425 // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
426 //                  0x1D = second key with even y, 0x1E = second key with odd y
427 bool CKey::SignCompact(uint256 hash, std::vector<unsigned char>& vchSig)
428 {
429     bool fOk = false;
430     ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
431     if (sig==NULL)
432         return false;
433     const EC_GROUP *group = EC_KEY_get0_group(pkey);
434     CBigNum order, halforder;
435     EC_GROUP_get_order(group, &order, NULL);
436     BN_rshift1(&halforder, &order);
437     // enforce low S values, by negating the value (modulo the order) if above order/2.
438     if (BN_cmp(sig->s, &halforder) > 0) {
439         BN_sub(sig->s, &order, sig->s);
440     }
441     vchSig.clear();
442     vchSig.resize(65,0);
443     int nBitsR = BN_num_bits(sig->r);
444     int nBitsS = BN_num_bits(sig->s);
445     if (nBitsR <= 256 && nBitsS <= 256)
446     {
447         int8_t nRecId = -1;
448         for (int8_t i=0; i<4; i++)
449         {
450             CKey keyRec;
451             keyRec.fSet = true;
452             if (fCompressedPubKey)
453                 keyRec.SetCompressedPubKey();
454             if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1)
455                 if (keyRec.GetPubKey() == this->GetPubKey())
456                 {
457                     nRecId = i;
458                     break;
459                 }
460         }
461
462         if (nRecId == -1)
463         {
464             ECDSA_SIG_free(sig);
465             throw key_error("CKey::SignCompact() : unable to construct recoverable key");
466         }
467
468         vchSig[0] = nRecId+27+(fCompressedPubKey ? 4 : 0);
469         BN_bn2bin(sig->r,&vchSig[33-(nBitsR+7)/8]);
470         BN_bn2bin(sig->s,&vchSig[65-(nBitsS+7)/8]);
471         fOk = true;
472     }
473     ECDSA_SIG_free(sig);
474     return fOk;
475 }
476
477 // reconstruct public key from a compact signature
478 // This is only slightly more CPU intensive than just verifying it.
479 // If this function succeeds, the recovered public key is guaranteed to be valid
480 // (the signature is a valid signature of the given data for that key)
481 bool CPubKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
482 {
483     if (vchSig.size() != 65)
484         return false;
485     int nV = vchSig[0];
486     if (nV<27 || nV>=35)
487         return false;
488     ECDSA_SIG *sig = ECDSA_SIG_new();
489     BN_bin2bn(&vchSig[1],32,sig->r);
490     BN_bin2bn(&vchSig[33],32,sig->s);
491
492     EC_KEY* pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
493     if (nV >= 31)
494     {
495         nV -= 4;
496         EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
497     }
498
499     do
500     {
501         if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), nV - 27, 0) != 1)
502             break;
503         ECDSA_SIG_free(sig);
504
505         int nSize = i2o_ECPublicKey(pkey, NULL);
506         if (!nSize)
507             break;
508         std::vector<unsigned char> vchPubKey(nSize, 0);
509         unsigned char* pbegin = &vchPubKey[0];
510         if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
511             break;
512         Set(vchPubKey.begin(), vchPubKey.end());
513         return IsValid();
514
515     } while (false);
516
517     ECDSA_SIG_free(sig);
518     Invalidate();
519     return false;
520 }
521
522 bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const
523 {
524     if (vchSig.empty() || !IsValid())
525         return false;
526
527     const unsigned char* pbegin = &vbytes[0];
528     EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
529     if (!o2i_ECPublicKey(&pkey, &pbegin, size()))
530         return false; // Unable to parse public key
531
532     // New versions of OpenSSL will reject non-canonical DER signatures. de/re-serialize first.
533     unsigned char *norm_der = NULL;
534     ECDSA_SIG *norm_sig = ECDSA_SIG_new();
535     const unsigned char* sigptr = &vchSig[0];
536     assert(norm_sig);
537     if (d2i_ECDSA_SIG(&norm_sig, &sigptr, vchSig.size()) == NULL)
538     {
539         /* As of OpenSSL 1.0.0p d2i_ECDSA_SIG frees and nulls the pointer on
540         * error. But OpenSSL's own use of this function redundantly frees the
541         * result. As ECDSA_SIG_free(NULL) is a no-op, and in the absence of a
542         * clear contract for the function behaving the same way is more
543         * conservative.
544         */
545         ECDSA_SIG_free(norm_sig);
546         return false;
547     }
548     int derlen = i2d_ECDSA_SIG(norm_sig, &norm_der);
549     ECDSA_SIG_free(norm_sig);
550     if (derlen <= 0)
551         return false;
552
553     // -1 = error, 0 = bad sig, 1 = good
554     bool ret = ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), norm_der, derlen, pkey) == 1;
555     OPENSSL_free(norm_der);
556     return ret;
557 }
558
559 bool CPubKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
560 {
561     CPubKey key;
562     if (!key.SetCompactSignature(hash, vchSig))
563         return false;
564     return true;
565 }
566
567 bool CKey::IsValid()
568 {
569     if (!fSet)
570         return false;
571
572     if (!EC_KEY_check_key(pkey))
573         return false;
574
575     bool fCompr;
576     CSecret secret = GetSecret(fCompr);
577     CKey key2;
578     key2.SetSecret(secret, fCompr);
579
580     return GetPubKey() == key2.GetPubKey();
581 }
582
583 CPoint::CPoint()
584 {
585     std::string err;
586     group = NULL;
587     point = NULL;
588     ctx   = NULL;
589
590     group = EC_GROUP_new_by_curve_name(NID_secp256k1);
591     if (!group) {
592         err = "EC_KEY_new_by_curve_name failed.";
593         goto finish;
594     }
595
596     point = EC_POINT_new(group);
597     if (!point) {
598         err = "EC_POINT_new failed.";
599         goto finish;
600     }
601
602     ctx = BN_CTX_new();
603     if (!ctx) {
604         err = "BN_CTX_new failed.";
605         goto finish;
606     }
607
608     return;
609
610 finish:
611     if (group) EC_GROUP_free(group);
612     if (point) EC_POINT_free(point);
613     throw std::runtime_error(std::string("CPoint::CPoint() :  - ") + err);
614 }
615
616 bool CPoint::operator!=(const CPoint &a)
617 {
618     if (EC_POINT_cmp(group, point, a.point, ctx) != 0)
619         return true;
620     return false;
621 }
622 CPoint::~CPoint()
623 {
624     if (point) EC_POINT_free(point);
625     if (group) EC_GROUP_free(group);
626     if (ctx)   BN_CTX_free(ctx);
627 }
628
629 // Initialize from octets stream
630 bool CPoint::setBytes(const std::vector<unsigned char> &vchBytes)
631 {
632     if (!EC_POINT_oct2point(group, point, &vchBytes[0], vchBytes.size(), ctx)) {
633         return false;
634     }
635     return true;
636 }
637
638 // Initialize from octets stream
639 bool CPoint::setPubKey(const CPubKey &key)
640 {
641     std::vector<uint8_t> vchPubKey(key.begin(), key.end());
642     return setBytes(vchPubKey);
643 }
644
645 // Serialize to octets stream
646 bool CPoint::getBytes(std::vector<unsigned char> &vchBytes)
647 {
648     size_t nSize = EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED, NULL, 0, ctx);
649     vchBytes.resize(nSize);
650     if (!(nSize == EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED, &vchBytes[0], nSize, ctx))) {
651         return false;
652     }
653     return true;
654 }
655
656 // ECC multiplication by specified multiplier
657 bool CPoint::ECMUL(const CBigNum &bnMultiplier)
658 {
659     if (!EC_POINT_mul(group, point, NULL, point, &bnMultiplier, NULL)) {
660         printf("CPoint::ECMUL() : EC_POINT_mul failed");
661         return false;
662     }
663
664     return true;
665 }
666
667 // Calculate G*m + q
668 bool CPoint::ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint)
669 {
670     if (!EC_POINT_mul(group, point, &bnMultiplier, qPoint.point, BN_value_one(), NULL)) {
671         printf("CPoint::ECMULGEN() : EC_POINT_mul failed.");
672         return false;
673     }
674
675     return true;
676 }
677
678 // CMalleablePubKey
679
680 void CMalleablePubKey::GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant)
681 {
682     EC_KEY *eckey = NULL;
683     eckey = EC_KEY_new_by_curve_name(NID_secp256k1);
684     if (eckey == NULL) {
685         throw key_error("CMalleablePubKey::GetVariant() : EC_KEY_new_by_curve_name failed");
686     }
687
688     // Use standard key generation function to get r and R values.
689     //
690     // r will be presented by private key;
691     // R is ECDSA public key which calculated as G*r
692     if (!EC_KEY_generate_key(eckey)) {
693         throw key_error("CMalleablePubKey::GetVariant() : EC_KEY_generate_key failed");
694     }
695
696     EC_KEY_set_conv_form(eckey, POINT_CONVERSION_COMPRESSED);
697
698     int nSize = i2o_ECPublicKey(eckey, NULL);
699     if (!nSize) {
700         throw key_error("CMalleablePubKey::GetVariant() : i2o_ECPublicKey failed");
701     }
702
703     std::vector<unsigned char> vchPubKey(nSize, 0);
704     unsigned char* pbegin_R = &vchPubKey[0];
705
706     if (i2o_ECPublicKey(eckey, &pbegin_R) != nSize) {
707         throw key_error("CMalleablePubKey::GetVariant() : i2o_ECPublicKey returned unexpected size");
708     }
709
710     // R = G*r
711     R = CPubKey(vchPubKey);
712
713     // OpenSSL BIGNUM representation of r value
714     CBigNum bnr;
715     bnr = *(CBigNum*) EC_KEY_get0_private_key(eckey);
716     EC_KEY_free(eckey);
717
718     CPoint point;
719     if (!point.setPubKey(pubKeyL)) {
720         throw key_error("CMalleablePubKey::GetVariant() : Unable to decode L value");
721     }
722
723     // Calculate L*r
724     point.ECMUL(bnr);
725
726     std::vector<unsigned char> vchLr;
727     if (!point.getBytes(vchLr)) {
728         throw key_error("CMalleablePubKey::GetVariant() : Unable to convert Lr value");
729     }
730
731     // Calculate Hash(L*r) and then get a BIGNUM representation of hash value.
732     CBigNum bnHash;
733     bnHash.setuint160(Hash160(vchLr));
734
735     CPoint pointH;
736     pointH.setPubKey(pubKeyH);
737
738     CPoint P;
739     // Calculate P = Hash(L*r)*G + H
740     P.ECMULGEN(bnHash, pointH);
741
742     if (P.IsInfinity()) {
743         throw key_error("CMalleablePubKey::GetVariant() : P is infinity");
744     }
745
746     std::vector<unsigned char> vchResult;
747     P.getBytes(vchResult);
748
749     vchPubKeyVariant = CPubKey(vchResult);
750 }
751
752 std::string CMalleablePubKey::ToString() const
753 {
754     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
755     ssKey << *this;
756     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
757
758     return EncodeBase58Check(vch);
759 }
760
761 bool CMalleablePubKey::setvch(const std::vector<unsigned char> &vchPubKeyPair)
762 {
763     CDataStream ssKey(vchPubKeyPair, SER_NETWORK, PROTOCOL_VERSION);
764     ssKey >> *this;
765
766     return IsValid();
767 }
768
769 std::vector<unsigned char> CMalleablePubKey::Raw() const
770 {
771     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
772     ssKey << *this;
773     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
774
775     return vch;
776 }
777
778 bool CMalleablePubKey::SetString(const std::string& strMalleablePubKey)
779 {
780     std::vector<unsigned char> vchTemp;
781     if (!DecodeBase58Check(strMalleablePubKey, vchTemp)) {
782         throw key_error("CMalleablePubKey::SetString() : Provided key data seems corrupted.");
783     }
784
785     CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
786     ssKey >> *this;
787
788     return IsValid();
789 }
790
791 bool CMalleablePubKey::operator==(const CMalleablePubKey &b)
792 {
793     return pubKeyL == b.pubKeyL && pubKeyH == b.pubKeyH;
794 }
795
796
797 // CMalleableKey
798
799 void CMalleableKey::Reset()
800 {
801     vchSecretL.clear();
802     vchSecretH.clear();
803 }
804
805 void CMalleableKey::MakeNewKeys()
806 {
807     Reset();
808
809     CKey keyL, keyH;
810     keyL.MakeNewKey();
811     keyH.MakeNewKey();
812
813     vchSecretL = keyL.GetSecret();
814     vchSecretH = keyH.GetSecret();
815 }
816
817 CMalleableKey::CMalleableKey()
818 {
819     Reset();
820 }
821
822 CMalleableKey::CMalleableKey(const CMalleableKey &b)
823 {
824     SetSecrets(b.vchSecretL, b.vchSecretH);
825 }
826
827 CMalleableKey::CMalleableKey(const CSecret &L, const CSecret &H)
828 {
829     SetSecrets(L, H);
830 }
831
832 CMalleableKey::~CMalleableKey()
833 {
834 }
835
836 bool CMalleableKey::IsNull() const
837 {
838     return vchSecretL.size() != 32 || vchSecretH.size() != 32;
839 }
840
841 bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH)
842 {
843     Reset();
844
845     CKey keyL(pvchSecretL);
846     CKey keyH(pvchSecretH);
847
848     if (!keyL.IsValid() || !keyH.IsValid())
849         return false;
850
851     vchSecretL = pvchSecretL;
852     vchSecretH = pvchSecretH;
853
854     return true;
855 }
856
857 CMalleablePubKey CMalleableKey::GetMalleablePubKey() const
858 {
859     CKey L(vchSecretL), H(vchSecretH);
860     return CMalleablePubKey(L.GetPubKey(), H.GetPubKey());
861 }
862
863 // Check ownership
864 bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
865 {
866     if (IsNull()) {
867         throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object.");
868     }
869
870     if (!R.IsValid()) {
871         printf("CMalleableKey::CheckKeyVariant() : R is invalid");
872         return false;
873     }
874
875     if (!vchPubKeyVariant.IsValid()) {
876         printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
877         return false;
878     }
879
880     CPoint point_R;
881     if (!point_R.setPubKey(R)) {
882         printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
883         return false;
884     }
885
886     CKey H(vchSecretH);
887     CPubKey vchPubKeyH = H.GetPubKey();
888
889     CPoint point_H;
890     if (!point_H.setPubKey(vchPubKeyH)) {
891         printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
892         return false;
893     }
894
895     CPoint point_P;
896     if (!point_P.setPubKey(vchPubKeyVariant)) {
897         printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
898         return false;
899     }
900
901     // Infinity points are senseless
902     if (point_P.IsInfinity()) {
903         printf("CMalleableKey::CheckKeyVariant() : P is infinity");
904         return false;
905     }
906
907     CBigNum bnl;
908     bnl.setBytes(std::vector<unsigned char>(vchSecretL.begin(), vchSecretL.end()));
909
910     point_R.ECMUL(bnl);
911
912     std::vector<unsigned char> vchRl;
913     if (!point_R.getBytes(vchRl)) {
914         printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
915         return false;
916     }
917
918     // Calculate Hash(R*l)
919     CBigNum bnHash;
920     bnHash.setuint160(Hash160(vchRl));
921
922     CPoint point_Ps;
923     // Calculate Ps = Hash(L*r)*G + H
924     point_Ps.ECMULGEN(bnHash, point_H);
925
926     // Infinity points are senseless
927     if (point_Ps.IsInfinity()) {
928         printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
929         return false;
930     }
931
932     // Check ownership
933     if (point_Ps != point_P) {
934         return false;
935     }
936
937     return true;
938 }
939
940 // Check ownership and restore private key
941 bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const
942 {
943     if (IsNull()) {
944         throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object.");
945     }
946
947     if (!R.IsValid()) {
948         printf("CMalleableKey::CheckKeyVariant() : R is invalid");
949         return false;
950     }
951
952     if (!vchPubKeyVariant.IsValid()) {
953         printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
954         return false;
955     }
956
957     CPoint point_R;
958     if (!point_R.setPubKey(R)) {
959         printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
960         return false;
961     }
962
963     CKey H(vchSecretH);
964     CPubKey vchPubKeyH = H.GetPubKey();
965
966     CPoint point_H;
967     if (!point_H.setPubKey(vchPubKeyH)) {
968         printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
969         return false;
970     }
971
972     CPoint point_P;
973     if (!point_P.setPubKey(vchPubKeyVariant)) {
974         printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
975         return false;
976     }
977
978     // Infinity points are senseless
979     if (point_P.IsInfinity()) {
980         printf("CMalleableKey::CheckKeyVariant() : P is infinity");
981         return false;
982     }
983
984     CBigNum bnl;
985     bnl.setBytes(std::vector<unsigned char>(vchSecretL.begin(), vchSecretL.end()));
986
987     point_R.ECMUL(bnl);
988
989     std::vector<unsigned char> vchRl;
990     if (!point_R.getBytes(vchRl)) {
991         printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
992         return false;
993     }
994
995     // Calculate Hash(R*l)
996     CBigNum bnHash;
997     bnHash.setuint160(Hash160(vchRl));
998
999     CPoint point_Ps;
1000     // Calculate Ps = Hash(L*r)*G + H
1001     point_Ps.ECMULGEN(bnHash, point_H);
1002
1003     // Infinity points are senseless
1004     if (point_Ps.IsInfinity()) {
1005         printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
1006         return false;
1007     }
1008
1009     // Check ownership
1010     if (point_Ps != point_P) {
1011         return false;
1012     }
1013
1014     // OpenSSL BIGNUM representation of the second private key from (l, h) pair
1015     CBigNum bnh;
1016     bnh.setBytes(std::vector<unsigned char>(vchSecretH.begin(), vchSecretH.end()));
1017
1018     // Calculate p = Hash(R*l) + h
1019     CBigNum bnp = bnHash + bnh;
1020
1021     std::vector<unsigned char> vchp = bnp.getBytes();
1022     privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()));
1023
1024     return true;
1025 }
1026
1027 std::string CMalleableKey::ToString() const
1028 {
1029     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
1030     ssKey << *this;
1031     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
1032
1033     return EncodeBase58Check(vch);
1034 }
1035
1036 std::vector<unsigned char> CMalleableKey::Raw() const
1037 {
1038     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
1039     ssKey << *this;
1040     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
1041
1042     return vch;
1043 }
1044
1045 bool CMalleableKey::SetString(const std::string& strMutableKey)
1046 {
1047     std::vector<unsigned char> vchTemp;
1048     if (!DecodeBase58Check(strMutableKey, vchTemp)) {
1049         throw key_error("CMalleableKey::SetString() : Provided key data seems corrupted.");
1050     }
1051
1052     CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
1053     ssKey >> *this;
1054
1055     return IsValid();
1056 }
1057
1058 // CMalleableKeyView
1059
1060 CMalleableKeyView::CMalleableKeyView(const std::string &strMalleableKey)
1061 {
1062     SetString(strMalleableKey);
1063 }
1064
1065 CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b)
1066 {
1067     if (b.vchSecretL.size() != 32)
1068         throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
1069
1070     if (b.vchSecretH.size() != 32)
1071         throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes");
1072
1073     vchSecretL = b.vchSecretL;
1074
1075     CKey H(b.vchSecretH);
1076     vchPubKeyH = H.GetPubKey();
1077 }
1078
1079 CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b)
1080 {
1081     vchSecretL = b.vchSecretL;
1082     vchPubKeyH = b.vchPubKeyH;
1083 }
1084
1085 CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b)
1086 {
1087     vchSecretL = b.vchSecretL;
1088
1089     CKey H(b.vchSecretH);
1090     vchPubKeyH = H.GetPubKey();
1091
1092     return (*this);
1093 }
1094
1095 CMalleableKeyView::~CMalleableKeyView()
1096 {
1097 }
1098
1099 CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const
1100 {
1101     CKey keyL(vchSecretL);
1102     return CMalleablePubKey(keyL.GetPubKey(), vchPubKeyH);
1103 }
1104
1105 // Check ownership
1106 bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
1107 {
1108     if (!IsValid()) {
1109         throw key_error("CMalleableKeyView::CheckKeyVariant() : Attempting to run on invalid view object.");
1110     }
1111
1112     if (!R.IsValid()) {
1113         printf("CMalleableKeyView::CheckKeyVariant() : R is invalid");
1114         return false;
1115     }
1116
1117     if (!vchPubKeyVariant.IsValid()) {
1118         printf("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
1119         return false;
1120     }
1121
1122     CPoint point_R;
1123     if (!point_R.setPubKey(R)) {
1124         printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
1125         return false;
1126     }
1127
1128     CPoint point_H;
1129     if (!point_H.setPubKey(vchPubKeyH)) {
1130         printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
1131         return false;
1132     }
1133
1134     CPoint point_P;
1135     if (!point_P.setPubKey(vchPubKeyVariant)) {
1136         printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
1137         return false;
1138     }
1139
1140     // Infinity points are senseless
1141     if (point_P.IsInfinity()) {
1142         printf("CMalleableKeyView::CheckKeyVariant() : P is infinity");
1143         return false;
1144     }
1145
1146     CBigNum bnl;
1147     bnl.setBytes(std::vector<unsigned char>(vchSecretL.begin(), vchSecretL.end()));
1148
1149     point_R.ECMUL(bnl);
1150
1151     std::vector<unsigned char> vchRl;
1152     if (!point_R.getBytes(vchRl)) {
1153         printf("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
1154         return false;
1155     }
1156
1157     // Calculate Hash(R*l)
1158     CBigNum bnHash;
1159     bnHash.setuint160(Hash160(vchRl));
1160
1161     CPoint point_Ps;
1162     // Calculate Ps = Hash(L*r)*G + H
1163     point_Ps.ECMULGEN(bnHash, point_H);
1164
1165     // Infinity points are senseless
1166     if (point_Ps.IsInfinity()) {
1167         printf("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
1168         return false;
1169     }
1170
1171     // Check ownership
1172     if (point_Ps != point_P) {
1173         return false;
1174     }
1175
1176     return true;
1177 }
1178
1179 std::string CMalleableKeyView::ToString() const
1180 {
1181     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
1182     ssKey << *this;
1183     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
1184
1185     return EncodeBase58Check(vch);
1186 }
1187
1188 bool CMalleableKeyView::SetString(const std::string& strMutableKey)
1189 {
1190     std::vector<unsigned char> vchTemp;
1191     if (!DecodeBase58Check(strMutableKey, vchTemp)) {
1192         throw key_error("CMalleableKeyView::SetString() : Provided key data seems corrupted.");
1193     }
1194
1195     CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
1196     ssKey >> *this;
1197
1198     return IsValid();
1199 }
1200
1201 std::vector<unsigned char> CMalleableKeyView::Raw() const
1202 {
1203     CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
1204     ssKey << *this;
1205     std::vector<unsigned char> vch(ssKey.begin(), ssKey.end());
1206
1207     return vch;
1208 }
1209
1210
1211 bool CMalleableKeyView::IsValid() const
1212 {
1213     return vchSecretL.size() == 32 && GetMalleablePubKey().IsValid();
1214 }
1215
1216 //// Asymmetric encryption
1217
1218 void CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
1219 {
1220     ies_ctx_t *ctx;
1221     char error[1024] = "Unknown error";
1222     cryptogram_t *cryptogram;
1223
1224     const unsigned char* pbegin = &vbytes[0];
1225     EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
1226     if (!o2i_ECPublicKey(&pkey, &pbegin, size()))
1227         throw key_error("Unable to parse EC key");
1228
1229     ctx = create_context(pkey);
1230     if (!EC_KEY_get0_public_key(ctx->user_key))
1231         throw key_error("Given EC key is not public key");
1232
1233     cryptogram = ecies_encrypt(ctx, (unsigned char*)&data[0], data.size(), error);
1234     if (cryptogram == NULL) {
1235         delete ctx;
1236         ctx = NULL;
1237         throw key_error(std::string("Error in encryption: %s") + error);
1238     }
1239
1240     encrypted.resize(cryptogram_data_sum_length(cryptogram));
1241     unsigned char *key_data = cryptogram_key_data(cryptogram);
1242     memcpy(&encrypted[0], key_data, encrypted.size());
1243     cryptogram_free(cryptogram);
1244     delete ctx;
1245 }
1246
1247 void CKey::DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data)
1248 {
1249     ies_ctx_t *ctx;
1250     char error[1024] = "Unknown error";
1251     cryptogram_t *cryptogram;
1252     size_t length;
1253     unsigned char *decrypted;
1254
1255     ctx = create_context(pkey);
1256     if (!EC_KEY_get0_private_key(ctx->user_key))
1257         throw key_error("Given EC key is not private key");
1258
1259     size_t key_length = ctx->stored_key_length;
1260     size_t mac_length = EVP_MD_size(ctx->md);
1261     cryptogram = cryptogram_alloc(key_length, mac_length, encrypted.size() - key_length - mac_length);
1262
1263     memcpy(cryptogram_key_data(cryptogram), &encrypted[0], encrypted.size());
1264
1265     decrypted = ecies_decrypt(ctx, cryptogram, &length, error);
1266     cryptogram_free(cryptogram);
1267     delete ctx;
1268
1269     if (decrypted == NULL) {
1270         throw key_error(std::string("Error in decryption: %s") + error);
1271     }
1272
1273     data.resize(length);
1274     memcpy(&data[0], decrypted, length);
1275     free(decrypted);
1276 }