mirror of https://github.com/ethereum/go-ethereum
Alexandre Van de Sande
10 years ago
commit
dea6584018
@ -1,77 +0,0 @@ |
||||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC |
||||
2898 / PKCS #5 v2.0. |
||||
|
||||
A key derivation function is useful when encrypting data based on a password |
||||
or any other not-fully-random data. It uses a pseudorandom function to derive |
||||
a secure encryption key based on the password. |
||||
|
||||
While v2.0 of the standard defines only one pseudorandom function to use, |
||||
HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS Approved |
||||
Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To |
||||
choose, you can pass the `New` functions from the different SHA packages to |
||||
pbkdf2.Key. |
||||
*/ |
||||
package pbkdf2 |
||||
|
||||
import ( |
||||
"crypto/hmac" |
||||
"hash" |
||||
) |
||||
|
||||
// Key derives a key from the password, salt and iteration count, returning a
|
||||
// []byte of length keylen that can be used as cryptographic key. The key is
|
||||
// derived based on the method described as PBKDF2 with the HMAC variant using
|
||||
// the supplied hash function.
|
||||
//
|
||||
// For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you
|
||||
// can get a derived key for e.g. AES-256 (which needs a 32-byte key) by
|
||||
// doing:
|
||||
//
|
||||
// dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New)
|
||||
//
|
||||
// Remember to get a good random salt. At least 8 bytes is recommended by the
|
||||
// RFC.
|
||||
//
|
||||
// Using a higher iteration count will increase the cost of an exhaustive
|
||||
// search but will also make derivation proportionally slower.
|
||||
func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte { |
||||
prf := hmac.New(h, password) |
||||
hashLen := prf.Size() |
||||
numBlocks := (keyLen + hashLen - 1) / hashLen |
||||
|
||||
var buf [4]byte |
||||
dk := make([]byte, 0, numBlocks*hashLen) |
||||
U := make([]byte, hashLen) |
||||
for block := 1; block <= numBlocks; block++ { |
||||
// N.B.: || means concatenation, ^ means XOR
|
||||
// for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
|
||||
// U_1 = PRF(password, salt || uint(i))
|
||||
prf.Reset() |
||||
prf.Write(salt) |
||||
buf[0] = byte(block >> 24) |
||||
buf[1] = byte(block >> 16) |
||||
buf[2] = byte(block >> 8) |
||||
buf[3] = byte(block) |
||||
prf.Write(buf[:4]) |
||||
dk = prf.Sum(dk) |
||||
T := dk[len(dk)-hashLen:] |
||||
copy(U, T) |
||||
|
||||
// U_n = PRF(password, U_(n-1))
|
||||
for n := 2; n <= iter; n++ { |
||||
prf.Reset() |
||||
prf.Write(U) |
||||
U = U[:0] |
||||
U = prf.Sum(U) |
||||
for x := range U { |
||||
T[x] ^= U[x] |
||||
} |
||||
} |
||||
} |
||||
return dk[:keyLen] |
||||
} |
||||
@ -1,157 +0,0 @@ |
||||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package pbkdf2 |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/sha1" |
||||
"crypto/sha256" |
||||
"hash" |
||||
"testing" |
||||
) |
||||
|
||||
type testVector struct { |
||||
password string |
||||
salt string |
||||
iter int |
||||
output []byte |
||||
} |
||||
|
||||
// Test vectors from RFC 6070, http://tools.ietf.org/html/rfc6070
|
||||
var sha1TestVectors = []testVector{ |
||||
{ |
||||
"password", |
||||
"salt", |
||||
1, |
||||
[]byte{ |
||||
0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71, |
||||
0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06, |
||||
0x2f, 0xe0, 0x37, 0xa6, |
||||
}, |
||||
}, |
||||
{ |
||||
"password", |
||||
"salt", |
||||
2, |
||||
[]byte{ |
||||
0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c, |
||||
0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0, |
||||
0xd8, 0xde, 0x89, 0x57, |
||||
}, |
||||
}, |
||||
{ |
||||
"password", |
||||
"salt", |
||||
4096, |
||||
[]byte{ |
||||
0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a, |
||||
0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0, |
||||
0x65, 0xa4, 0x29, 0xc1, |
||||
}, |
||||
}, |
||||
// // This one takes too long
|
||||
// {
|
||||
// "password",
|
||||
// "salt",
|
||||
// 16777216,
|
||||
// []byte{
|
||||
// 0xee, 0xfe, 0x3d, 0x61, 0xcd, 0x4d, 0xa4, 0xe4,
|
||||
// 0xe9, 0x94, 0x5b, 0x3d, 0x6b, 0xa2, 0x15, 0x8c,
|
||||
// 0x26, 0x34, 0xe9, 0x84,
|
||||
// },
|
||||
// },
|
||||
{ |
||||
"passwordPASSWORDpassword", |
||||
"saltSALTsaltSALTsaltSALTsaltSALTsalt", |
||||
4096, |
||||
[]byte{ |
||||
0x3d, 0x2e, 0xec, 0x4f, 0xe4, 0x1c, 0x84, 0x9b, |
||||
0x80, 0xc8, 0xd8, 0x36, 0x62, 0xc0, 0xe4, 0x4a, |
||||
0x8b, 0x29, 0x1a, 0x96, 0x4c, 0xf2, 0xf0, 0x70, |
||||
0x38, |
||||
}, |
||||
}, |
||||
{ |
||||
"pass\000word", |
||||
"sa\000lt", |
||||
4096, |
||||
[]byte{ |
||||
0x56, 0xfa, 0x6a, 0xa7, 0x55, 0x48, 0x09, 0x9d, |
||||
0xcc, 0x37, 0xd7, 0xf0, 0x34, 0x25, 0xe0, 0xc3, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
// Test vectors from
|
||||
// http://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors
|
||||
var sha256TestVectors = []testVector{ |
||||
{ |
||||
"password", |
||||
"salt", |
||||
1, |
||||
[]byte{ |
||||
0x12, 0x0f, 0xb6, 0xcf, 0xfc, 0xf8, 0xb3, 0x2c, |
||||
0x43, 0xe7, 0x22, 0x52, 0x56, 0xc4, 0xf8, 0x37, |
||||
0xa8, 0x65, 0x48, 0xc9, |
||||
}, |
||||
}, |
||||
{ |
||||
"password", |
||||
"salt", |
||||
2, |
||||
[]byte{ |
||||
0xae, 0x4d, 0x0c, 0x95, 0xaf, 0x6b, 0x46, 0xd3, |
||||
0x2d, 0x0a, 0xdf, 0xf9, 0x28, 0xf0, 0x6d, 0xd0, |
||||
0x2a, 0x30, 0x3f, 0x8e, |
||||
}, |
||||
}, |
||||
{ |
||||
"password", |
||||
"salt", |
||||
4096, |
||||
[]byte{ |
||||
0xc5, 0xe4, 0x78, 0xd5, 0x92, 0x88, 0xc8, 0x41, |
||||
0xaa, 0x53, 0x0d, 0xb6, 0x84, 0x5c, 0x4c, 0x8d, |
||||
0x96, 0x28, 0x93, 0xa0, |
||||
}, |
||||
}, |
||||
{ |
||||
"passwordPASSWORDpassword", |
||||
"saltSALTsaltSALTsaltSALTsaltSALTsalt", |
||||
4096, |
||||
[]byte{ |
||||
0x34, 0x8c, 0x89, 0xdb, 0xcb, 0xd3, 0x2b, 0x2f, |
||||
0x32, 0xd8, 0x14, 0xb8, 0x11, 0x6e, 0x84, 0xcf, |
||||
0x2b, 0x17, 0x34, 0x7e, 0xbc, 0x18, 0x00, 0x18, |
||||
0x1c, |
||||
}, |
||||
}, |
||||
{ |
||||
"pass\000word", |
||||
"sa\000lt", |
||||
4096, |
||||
[]byte{ |
||||
0x89, 0xb6, 0x9d, 0x05, 0x16, 0xf8, 0x29, 0x89, |
||||
0x3c, 0x69, 0x62, 0x26, 0x65, 0x0a, 0x86, 0x87, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
func testHash(t *testing.T, h func() hash.Hash, hashName string, vectors []testVector) { |
||||
for i, v := range vectors { |
||||
o := Key([]byte(v.password), []byte(v.salt), v.iter, len(v.output), h) |
||||
if !bytes.Equal(o, v.output) { |
||||
t.Errorf("%s %d: expected %x, got %x", hashName, i, v.output, o) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestWithHMACSHA1(t *testing.T) { |
||||
testHash(t, sha1.New, "SHA1", sha1TestVectors) |
||||
} |
||||
|
||||
func TestWithHMACSHA256(t *testing.T) { |
||||
testHash(t, sha256.New, "SHA256", sha256TestVectors) |
||||
} |
||||
@ -1,24 +0,0 @@ |
||||
# Compiled Object files, Static and Dynamic libs (Shared Objects) |
||||
*.o |
||||
*.a |
||||
*.so |
||||
|
||||
# Folders |
||||
_obj |
||||
_test |
||||
|
||||
# Architecture specific extensions/prefixes |
||||
*.[568vq] |
||||
[568vq].out |
||||
|
||||
*.cgo1.go |
||||
*.cgo2.c |
||||
_cgo_defun.c |
||||
_cgo_gotypes.go |
||||
_cgo_export.* |
||||
|
||||
_testmain.go |
||||
|
||||
*.exe |
||||
|
||||
*~ |
||||
@ -1,28 +0,0 @@ |
||||
Copyright (c) 2013 Kyle Isom <kyle@tyrfingr.is> |
||||
Copyright (c) 2012 The Go Authors. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -1,94 +0,0 @@ |
||||
# NOTE |
||||
|
||||
This implementation is direct fork of Kylom's implementation. I claim no authorship over this code apart from some minor modifications. |
||||
Please be aware this code **has not yet been reviewed**. |
||||
|
||||
ecies implements the Elliptic Curve Integrated Encryption Scheme. |
||||
|
||||
The package is designed to be compliant with the appropriate NIST |
||||
standards, and therefore doesn't support the full SEC 1 algorithm set. |
||||
|
||||
|
||||
STATUS: |
||||
|
||||
ecies should be ready for use. The ASN.1 support is only complete so |
||||
far as to supported the listed algorithms before. |
||||
|
||||
|
||||
CAVEATS |
||||
|
||||
1. CMAC support is currently not present. |
||||
|
||||
|
||||
SUPPORTED ALGORITHMS |
||||
|
||||
SYMMETRIC CIPHERS HASH FUNCTIONS |
||||
AES128 SHA-1 |
||||
AES192 SHA-224 |
||||
AES256 SHA-256 |
||||
SHA-384 |
||||
ELLIPTIC CURVE SHA-512 |
||||
P256 |
||||
P384 KEY DERIVATION FUNCTION |
||||
P521 NIST SP 800-65a Concatenation KDF |
||||
|
||||
Curve P224 isn't supported because it does not provide a minimum security |
||||
level of AES128 with HMAC-SHA1. According to NIST SP 800-57, the security |
||||
level of P224 is 112 bits of security. Symmetric ciphers use CTR-mode; |
||||
message tags are computed using HMAC-<HASH> function. |
||||
|
||||
|
||||
CURVE SELECTION |
||||
|
||||
According to NIST SP 800-57, the following curves should be selected: |
||||
|
||||
+----------------+-------+ |
||||
| SYMMETRIC SIZE | CURVE | |
||||
+----------------+-------+ |
||||
| 128-bit | P256 | |
||||
+----------------+-------+ |
||||
| 192-bit | P384 | |
||||
+----------------+-------+ |
||||
| 256-bit | P521 | |
||||
+----------------+-------+ |
||||
|
||||
|
||||
TODO |
||||
|
||||
1. Look at serialising the parameters with the SEC 1 ASN.1 module. |
||||
2. Validate ASN.1 formats with SEC 1. |
||||
|
||||
|
||||
TEST VECTORS |
||||
|
||||
The only test vectors I've found so far date from 1993, predating AES |
||||
and including only 163-bit curves. Therefore, there are no published |
||||
test vectors to compare to. |
||||
|
||||
|
||||
LICENSE |
||||
|
||||
ecies is released under the same license as the Go source code. See the |
||||
LICENSE file for details. |
||||
|
||||
|
||||
REFERENCES |
||||
|
||||
* SEC (Standard for Efficient Cryptography) 1, version 2.0: Elliptic |
||||
Curve Cryptography; Certicom, May 2009. |
||||
http://www.secg.org/sec1-v2.pdf |
||||
* GEC (Guidelines for Efficient Cryptography) 2, version 0.3: Test |
||||
Vectors for SEC 1; Certicom, September 1999. |
||||
http://read.pudn.com/downloads168/doc/772358/TestVectorsforSEC%201-gec2.pdf |
||||
* NIST SP 800-56a: Recommendation for Pair-Wise Key Establishment Schemes |
||||
Using Discrete Logarithm Cryptography. National Institute of Standards |
||||
and Technology, May 2007. |
||||
http://csrc.nist.gov/publications/nistpubs/800-56A/SP800-56A_Revision1_Mar08-2007.pdf |
||||
* Suite B Implementer’s Guide to NIST SP 800-56A. National Security |
||||
Agency, July 28, 2009. |
||||
http://www.nsa.gov/ia/_files/SuiteB_Implementer_G-113808.pdf |
||||
* NIST SP 800-57: Recommendation for Key Management – Part 1: General |
||||
(Revision 3). National Institute of Standards and Technology, July |
||||
2012. |
||||
http://csrc.nist.gov/publications/nistpubs/800-57/sp800-57_part1_rev3_general.pdf |
||||
|
||||
@ -1,556 +0,0 @@ |
||||
package ecies |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto" |
||||
"crypto/elliptic" |
||||
"crypto/sha1" |
||||
"crypto/sha256" |
||||
"crypto/sha512" |
||||
"encoding/asn1" |
||||
"encoding/pem" |
||||
"fmt" |
||||
"hash" |
||||
"math/big" |
||||
) |
||||
|
||||
var ( |
||||
secgScheme = []int{1, 3, 132, 1} |
||||
shaScheme = []int{2, 16, 840, 1, 101, 3, 4, 2} |
||||
ansiX962Scheme = []int{1, 2, 840, 10045} |
||||
x963Scheme = []int{1, 2, 840, 63, 0} |
||||
) |
||||
|
||||
var ErrInvalidPrivateKey = fmt.Errorf("ecies: invalid private key") |
||||
|
||||
func doScheme(base, v []int) asn1.ObjectIdentifier { |
||||
var oidInts asn1.ObjectIdentifier |
||||
oidInts = append(oidInts, base...) |
||||
return append(oidInts, v...) |
||||
} |
||||
|
||||
// curve OID code taken from crypto/x509, including
|
||||
// - oidNameCurve*
|
||||
// - namedCurveFromOID
|
||||
// - oidFromNamedCurve
|
||||
// RFC 5480, 2.1.1.1. Named Curve
|
||||
//
|
||||
// secp224r1 OBJECT IDENTIFIER ::= {
|
||||
// iso(1) identified-organization(3) certicom(132) curve(0) 33 }
|
||||
//
|
||||
// secp256r1 OBJECT IDENTIFIER ::= {
|
||||
// iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3)
|
||||
// prime(1) 7 }
|
||||
//
|
||||
// secp384r1 OBJECT IDENTIFIER ::= {
|
||||
// iso(1) identified-organization(3) certicom(132) curve(0) 34 }
|
||||
//
|
||||
// secp521r1 OBJECT IDENTIFIER ::= {
|
||||
// iso(1) identified-organization(3) certicom(132) curve(0) 35 }
|
||||
//
|
||||
// NB: secp256r1 is equivalent to prime256v1
|
||||
type secgNamedCurve asn1.ObjectIdentifier |
||||
|
||||
var ( |
||||
secgNamedCurveP224 = secgNamedCurve{1, 3, 132, 0, 33} |
||||
secgNamedCurveP256 = secgNamedCurve{1, 2, 840, 10045, 3, 1, 7} |
||||
secgNamedCurveP384 = secgNamedCurve{1, 3, 132, 0, 34} |
||||
secgNamedCurveP521 = secgNamedCurve{1, 3, 132, 0, 35} |
||||
rawCurveP224 = []byte{6, 5, 4, 3, 1, 2, 9, 4, 0, 3, 3} |
||||
rawCurveP256 = []byte{6, 8, 4, 2, 1, 3, 4, 7, 2, 2, 0, 6, 6, 1, 3, 1, 7} |
||||
rawCurveP384 = []byte{6, 5, 4, 3, 1, 2, 9, 4, 0, 3, 4} |
||||
rawCurveP521 = []byte{6, 5, 4, 3, 1, 2, 9, 4, 0, 3, 5} |
||||
) |
||||
|
||||
func rawCurve(curve elliptic.Curve) []byte { |
||||
switch curve { |
||||
case elliptic.P224(): |
||||
return rawCurveP224 |
||||
case elliptic.P256(): |
||||
return rawCurveP256 |
||||
case elliptic.P384(): |
||||
return rawCurveP384 |
||||
case elliptic.P521(): |
||||
return rawCurveP521 |
||||
default: |
||||
return nil |
||||
} |
||||
} |
||||
|
||||
func (curve secgNamedCurve) Equal(curve2 secgNamedCurve) bool { |
||||
if len(curve) != len(curve2) { |
||||
return false |
||||
} |
||||
for i, _ := range curve { |
||||
if curve[i] != curve2[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func namedCurveFromOID(curve secgNamedCurve) elliptic.Curve { |
||||
switch { |
||||
case curve.Equal(secgNamedCurveP224): |
||||
return elliptic.P224() |
||||
case curve.Equal(secgNamedCurveP256): |
||||
return elliptic.P256() |
||||
case curve.Equal(secgNamedCurveP384): |
||||
return elliptic.P384() |
||||
case curve.Equal(secgNamedCurveP521): |
||||
return elliptic.P521() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func oidFromNamedCurve(curve elliptic.Curve) (secgNamedCurve, bool) { |
||||
switch curve { |
||||
case elliptic.P224(): |
||||
return secgNamedCurveP224, true |
||||
case elliptic.P256(): |
||||
return secgNamedCurveP256, true |
||||
case elliptic.P384(): |
||||
return secgNamedCurveP384, true |
||||
case elliptic.P521(): |
||||
return secgNamedCurveP521, true |
||||
} |
||||
|
||||
return nil, false |
||||
} |
||||
|
||||
// asnAlgorithmIdentifier represents the ASN.1 structure of the same name. See RFC
|
||||
// 5280, section 4.1.1.2.
|
||||
type asnAlgorithmIdentifier struct { |
||||
Algorithm asn1.ObjectIdentifier |
||||
Parameters asn1.RawValue `asn1:"optional"` |
||||
} |
||||
|
||||
func (a asnAlgorithmIdentifier) Cmp(b asnAlgorithmIdentifier) bool { |
||||
if len(a.Algorithm) != len(b.Algorithm) { |
||||
return false |
||||
} |
||||
for i, _ := range a.Algorithm { |
||||
if a.Algorithm[i] != b.Algorithm[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
type asnHashFunction asnAlgorithmIdentifier |
||||
|
||||
var ( |
||||
oidSHA1 = asn1.ObjectIdentifier{1, 3, 14, 3, 2, 26} |
||||
oidSHA224 = doScheme(shaScheme, []int{4}) |
||||
oidSHA256 = doScheme(shaScheme, []int{1}) |
||||
oidSHA384 = doScheme(shaScheme, []int{2}) |
||||
oidSHA512 = doScheme(shaScheme, []int{3}) |
||||
) |
||||
|
||||
func hashFromOID(oid asn1.ObjectIdentifier) func() hash.Hash { |
||||
switch { |
||||
case oid.Equal(oidSHA1): |
||||
return sha1.New |
||||
case oid.Equal(oidSHA224): |
||||
return sha256.New224 |
||||
case oid.Equal(oidSHA256): |
||||
return sha256.New |
||||
case oid.Equal(oidSHA384): |
||||
return sha512.New384 |
||||
case oid.Equal(oidSHA512): |
||||
return sha512.New |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func oidFromHash(hash crypto.Hash) (asn1.ObjectIdentifier, bool) { |
||||
switch hash { |
||||
case crypto.SHA1: |
||||
return oidSHA1, true |
||||
case crypto.SHA224: |
||||
return oidSHA224, true |
||||
case crypto.SHA256: |
||||
return oidSHA256, true |
||||
case crypto.SHA384: |
||||
return oidSHA384, true |
||||
case crypto.SHA512: |
||||
return oidSHA512, true |
||||
default: |
||||
return nil, false |
||||
} |
||||
} |
||||
|
||||
var ( |
||||
asnAlgoSHA1 = asnHashFunction{ |
||||
Algorithm: oidSHA1, |
||||
} |
||||
asnAlgoSHA224 = asnHashFunction{ |
||||
Algorithm: oidSHA224, |
||||
} |
||||
asnAlgoSHA256 = asnHashFunction{ |
||||
Algorithm: oidSHA256, |
||||
} |
||||
asnAlgoSHA384 = asnHashFunction{ |
||||
Algorithm: oidSHA384, |
||||
} |
||||
asnAlgoSHA512 = asnHashFunction{ |
||||
Algorithm: oidSHA512, |
||||
} |
||||
) |
||||
|
||||
// type ASNasnSubjectPublicKeyInfo struct {
|
||||
//
|
||||
// }
|
||||
//
|
||||
|
||||
type asnSubjectPublicKeyInfo struct { |
||||
Algorithm asn1.ObjectIdentifier |
||||
PublicKey asn1.BitString |
||||
Supplements ecpksSupplements `asn1:"optional"` |
||||
} |
||||
|
||||
type asnECPKAlgorithms struct { |
||||
Type asn1.ObjectIdentifier |
||||
} |
||||
|
||||
var idPublicKeyType = doScheme(ansiX962Scheme, []int{2}) |
||||
var idEcPublicKey = doScheme(idPublicKeyType, []int{1}) |
||||
var idEcPublicKeySupplemented = doScheme(idPublicKeyType, []int{0}) |
||||
|
||||
func curveToRaw(curve elliptic.Curve) (rv asn1.RawValue, ok bool) { |
||||
switch curve { |
||||
case elliptic.P224(), elliptic.P256(), elliptic.P384(), elliptic.P521(): |
||||
raw := rawCurve(curve) |
||||
return asn1.RawValue{ |
||||
Tag: 30, |
||||
Bytes: raw[2:], |
||||
FullBytes: raw, |
||||
}, true |
||||
default: |
||||
return rv, false |
||||
} |
||||
} |
||||
|
||||
func asnECPublicKeyType(curve elliptic.Curve) (algo asnAlgorithmIdentifier, ok bool) { |
||||
raw, ok := curveToRaw(curve) |
||||
if !ok { |
||||
return |
||||
} else { |
||||
return asnAlgorithmIdentifier{Algorithm: idEcPublicKey, |
||||
Parameters: raw}, true |
||||
} |
||||
} |
||||
|
||||
type asnECPrivKeyVer int |
||||
|
||||
var asnECPrivKeyVer1 asnECPrivKeyVer = 1 |
||||
|
||||
type asnPrivateKey struct { |
||||
Version asnECPrivKeyVer |
||||
Private []byte |
||||
Curve secgNamedCurve `asn1:"optional"` |
||||
Public asn1.BitString |
||||
} |
||||
|
||||
var asnECDH = doScheme(secgScheme, []int{12}) |
||||
|
||||
type asnECDHAlgorithm asnAlgorithmIdentifier |
||||
|
||||
var ( |
||||
dhSinglePass_stdDH_sha1kdf = asnECDHAlgorithm{ |
||||
Algorithm: doScheme(x963Scheme, []int{2}), |
||||
} |
||||
dhSinglePass_stdDH_sha256kdf = asnECDHAlgorithm{ |
||||
Algorithm: doScheme(secgScheme, []int{11, 1}), |
||||
} |
||||
dhSinglePass_stdDH_sha384kdf = asnECDHAlgorithm{ |
||||
Algorithm: doScheme(secgScheme, []int{11, 2}), |
||||
} |
||||
dhSinglePass_stdDH_sha224kdf = asnECDHAlgorithm{ |
||||
Algorithm: doScheme(secgScheme, []int{11, 0}), |
||||
} |
||||
dhSinglePass_stdDH_sha512kdf = asnECDHAlgorithm{ |
||||
Algorithm: doScheme(secgScheme, []int{11, 3}), |
||||
} |
||||
) |
||||
|
||||
func (a asnECDHAlgorithm) Cmp(b asnECDHAlgorithm) bool { |
||||
if len(a.Algorithm) != len(b.Algorithm) { |
||||
return false |
||||
} |
||||
for i, _ := range a.Algorithm { |
||||
if a.Algorithm[i] != b.Algorithm[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// asnNISTConcatenation is the only supported KDF at this time.
|
||||
type asnKeyDerivationFunction asnAlgorithmIdentifier |
||||
|
||||
var asnNISTConcatenationKDF = asnKeyDerivationFunction{ |
||||
Algorithm: doScheme(secgScheme, []int{17, 1}), |
||||
} |
||||
|
||||
func (a asnKeyDerivationFunction) Cmp(b asnKeyDerivationFunction) bool { |
||||
if len(a.Algorithm) != len(b.Algorithm) { |
||||
return false |
||||
} |
||||
for i, _ := range a.Algorithm { |
||||
if a.Algorithm[i] != b.Algorithm[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
var eciesRecommendedParameters = doScheme(secgScheme, []int{7}) |
||||
var eciesSpecifiedParameters = doScheme(secgScheme, []int{8}) |
||||
|
||||
type asnECIESParameters struct { |
||||
KDF asnKeyDerivationFunction `asn1:"optional"` |
||||
Sym asnSymmetricEncryption `asn1:"optional"` |
||||
MAC asnMessageAuthenticationCode `asn1:"optional"` |
||||
} |
||||
|
||||
type asnSymmetricEncryption asnAlgorithmIdentifier |
||||
|
||||
var ( |
||||
aes128CTRinECIES = asnSymmetricEncryption{ |
||||
Algorithm: doScheme(secgScheme, []int{21, 0}), |
||||
} |
||||
aes192CTRinECIES = asnSymmetricEncryption{ |
||||
Algorithm: doScheme(secgScheme, []int{21, 1}), |
||||
} |
||||
aes256CTRinECIES = asnSymmetricEncryption{ |
||||
Algorithm: doScheme(secgScheme, []int{21, 2}), |
||||
} |
||||
) |
||||
|
||||
func (a asnSymmetricEncryption) Cmp(b asnSymmetricEncryption) bool { |
||||
if len(a.Algorithm) != len(b.Algorithm) { |
||||
return false |
||||
} |
||||
for i, _ := range a.Algorithm { |
||||
if a.Algorithm[i] != b.Algorithm[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
type asnMessageAuthenticationCode asnAlgorithmIdentifier |
||||
|
||||
var ( |
||||
hmacFull = asnMessageAuthenticationCode{ |
||||
Algorithm: doScheme(secgScheme, []int{22}), |
||||
} |
||||
) |
||||
|
||||
func (a asnMessageAuthenticationCode) Cmp(b asnMessageAuthenticationCode) bool { |
||||
if len(a.Algorithm) != len(b.Algorithm) { |
||||
return false |
||||
} |
||||
for i, _ := range a.Algorithm { |
||||
if a.Algorithm[i] != b.Algorithm[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
type ecpksSupplements struct { |
||||
ECDomain secgNamedCurve |
||||
ECCAlgorithms eccAlgorithmSet |
||||
} |
||||
|
||||
type eccAlgorithmSet struct { |
||||
ECDH asnECDHAlgorithm `asn1:"optional"` |
||||
ECIES asnECIESParameters `asn1:"optional"` |
||||
} |
||||
|
||||
func marshalSubjectPublicKeyInfo(pub *PublicKey) (subj asnSubjectPublicKeyInfo, err error) { |
||||
subj.Algorithm = idEcPublicKeySupplemented |
||||
curve, ok := oidFromNamedCurve(pub.Curve) |
||||
if !ok { |
||||
err = ErrInvalidPublicKey |
||||
return |
||||
} |
||||
subj.Supplements.ECDomain = curve |
||||
if pub.Params != nil { |
||||
subj.Supplements.ECCAlgorithms.ECDH = paramsToASNECDH(pub.Params) |
||||
subj.Supplements.ECCAlgorithms.ECIES = paramsToASNECIES(pub.Params) |
||||
} |
||||
pubkey := elliptic.Marshal(pub.Curve, pub.X, pub.Y) |
||||
subj.PublicKey = asn1.BitString{ |
||||
BitLength: len(pubkey) * 8, |
||||
Bytes: pubkey, |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Encode a public key to DER format.
|
||||
func MarshalPublic(pub *PublicKey) ([]byte, error) { |
||||
subj, err := marshalSubjectPublicKeyInfo(pub) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return asn1.Marshal(subj) |
||||
} |
||||
|
||||
// Decode a DER-encoded public key.
|
||||
func UnmarshalPublic(in []byte) (pub *PublicKey, err error) { |
||||
var subj asnSubjectPublicKeyInfo |
||||
|
||||
if _, err = asn1.Unmarshal(in, &subj); err != nil { |
||||
return |
||||
} |
||||
if !subj.Algorithm.Equal(idEcPublicKeySupplemented) { |
||||
err = ErrInvalidPublicKey |
||||
return |
||||
} |
||||
pub = new(PublicKey) |
||||
pub.Curve = namedCurveFromOID(subj.Supplements.ECDomain) |
||||
x, y := elliptic.Unmarshal(pub.Curve, subj.PublicKey.Bytes) |
||||
if x == nil { |
||||
err = ErrInvalidPublicKey |
||||
return |
||||
} |
||||
pub.X = x |
||||
pub.Y = y |
||||
pub.Params = new(ECIESParams) |
||||
asnECIEStoParams(subj.Supplements.ECCAlgorithms.ECIES, pub.Params) |
||||
asnECDHtoParams(subj.Supplements.ECCAlgorithms.ECDH, pub.Params) |
||||
if pub.Params == nil { |
||||
if pub.Params = ParamsFromCurve(pub.Curve); pub.Params == nil { |
||||
err = ErrInvalidPublicKey |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func marshalPrivateKey(prv *PrivateKey) (ecprv asnPrivateKey, err error) { |
||||
ecprv.Version = asnECPrivKeyVer1 |
||||
ecprv.Private = prv.D.Bytes() |
||||
|
||||
var ok bool |
||||
ecprv.Curve, ok = oidFromNamedCurve(prv.PublicKey.Curve) |
||||
if !ok { |
||||
err = ErrInvalidPrivateKey |
||||
return |
||||
} |
||||
|
||||
var pub []byte |
||||
if pub, err = MarshalPublic(&prv.PublicKey); err != nil { |
||||
return |
||||
} else { |
||||
ecprv.Public = asn1.BitString{ |
||||
BitLength: len(pub) * 8, |
||||
Bytes: pub, |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Encode a private key to DER format.
|
||||
func MarshalPrivate(prv *PrivateKey) ([]byte, error) { |
||||
ecprv, err := marshalPrivateKey(prv) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return asn1.Marshal(ecprv) |
||||
} |
||||
|
||||
// Decode a private key from a DER-encoded format.
|
||||
func UnmarshalPrivate(in []byte) (prv *PrivateKey, err error) { |
||||
var ecprv asnPrivateKey |
||||
|
||||
if _, err = asn1.Unmarshal(in, &ecprv); err != nil { |
||||
return |
||||
} else if ecprv.Version != asnECPrivKeyVer1 { |
||||
err = ErrInvalidPrivateKey |
||||
return |
||||
} |
||||
|
||||
privateCurve := namedCurveFromOID(ecprv.Curve) |
||||
if privateCurve == nil { |
||||
err = ErrInvalidPrivateKey |
||||
return |
||||
} |
||||
|
||||
prv = new(PrivateKey) |
||||
prv.D = new(big.Int).SetBytes(ecprv.Private) |
||||
|
||||
if pub, err := UnmarshalPublic(ecprv.Public.Bytes); err != nil { |
||||
return nil, err |
||||
} else { |
||||
prv.PublicKey = *pub |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
// Export a public key to PEM format.
|
||||
func ExportPublicPEM(pub *PublicKey) (out []byte, err error) { |
||||
der, err := MarshalPublic(pub) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
var block pem.Block |
||||
block.Type = "ELLIPTIC CURVE PUBLIC KEY" |
||||
block.Bytes = der |
||||
|
||||
buf := new(bytes.Buffer) |
||||
err = pem.Encode(buf, &block) |
||||
if err != nil { |
||||
return |
||||
} else { |
||||
out = buf.Bytes() |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Export a private key to PEM format.
|
||||
func ExportPrivatePEM(prv *PrivateKey) (out []byte, err error) { |
||||
der, err := MarshalPrivate(prv) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
var block pem.Block |
||||
block.Type = "ELLIPTIC CURVE PRIVATE KEY" |
||||
block.Bytes = der |
||||
|
||||
buf := new(bytes.Buffer) |
||||
err = pem.Encode(buf, &block) |
||||
if err != nil { |
||||
return |
||||
} else { |
||||
out = buf.Bytes() |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Import a PEM-encoded public key.
|
||||
func ImportPublicPEM(in []byte) (pub *PublicKey, err error) { |
||||
p, _ := pem.Decode(in) |
||||
if p == nil || p.Type != "ELLIPTIC CURVE PUBLIC KEY" { |
||||
return nil, ErrInvalidPublicKey |
||||
} |
||||
|
||||
pub, err = UnmarshalPublic(p.Bytes) |
||||
return |
||||
} |
||||
|
||||
// Import a PEM-encoded private key.
|
||||
func ImportPrivatePEM(in []byte) (prv *PrivateKey, err error) { |
||||
p, _ := pem.Decode(in) |
||||
if p == nil || p.Type != "ELLIPTIC CURVE PRIVATE KEY" { |
||||
return nil, ErrInvalidPrivateKey |
||||
} |
||||
|
||||
prv, err = UnmarshalPrivate(p.Bytes) |
||||
return |
||||
} |
||||
@ -1,326 +0,0 @@ |
||||
package ecies |
||||
|
||||
import ( |
||||
"crypto/cipher" |
||||
"crypto/ecdsa" |
||||
"crypto/elliptic" |
||||
"crypto/hmac" |
||||
"crypto/subtle" |
||||
"fmt" |
||||
"hash" |
||||
"io" |
||||
"math/big" |
||||
) |
||||
|
||||
var ( |
||||
ErrImport = fmt.Errorf("ecies: failed to import key") |
||||
ErrInvalidCurve = fmt.Errorf("ecies: invalid elliptic curve") |
||||
ErrInvalidParams = fmt.Errorf("ecies: invalid ECIES parameters") |
||||
ErrInvalidPublicKey = fmt.Errorf("ecies: invalid public key") |
||||
ErrSharedKeyTooBig = fmt.Errorf("ecies: shared key is too big") |
||||
) |
||||
|
||||
// PublicKey is a representation of an elliptic curve public key.
|
||||
type PublicKey struct { |
||||
X *big.Int |
||||
Y *big.Int |
||||
elliptic.Curve |
||||
Params *ECIESParams |
||||
} |
||||
|
||||
// Export an ECIES public key as an ECDSA public key.
|
||||
func (pub *PublicKey) ExportECDSA() *ecdsa.PublicKey { |
||||
return &ecdsa.PublicKey{pub.Curve, pub.X, pub.Y} |
||||
} |
||||
|
||||
// Import an ECDSA public key as an ECIES public key.
|
||||
func ImportECDSAPublic(pub *ecdsa.PublicKey) *PublicKey { |
||||
return &PublicKey{ |
||||
X: pub.X, |
||||
Y: pub.Y, |
||||
Curve: pub.Curve, |
||||
Params: ParamsFromCurve(pub.Curve), |
||||
} |
||||
} |
||||
|
||||
// PrivateKey is a representation of an elliptic curve private key.
|
||||
type PrivateKey struct { |
||||
PublicKey |
||||
D *big.Int |
||||
} |
||||
|
||||
// Export an ECIES private key as an ECDSA private key.
|
||||
func (prv *PrivateKey) ExportECDSA() *ecdsa.PrivateKey { |
||||
pub := &prv.PublicKey |
||||
pubECDSA := pub.ExportECDSA() |
||||
return &ecdsa.PrivateKey{*pubECDSA, prv.D} |
||||
} |
||||
|
||||
// Import an ECDSA private key as an ECIES private key.
|
||||
func ImportECDSA(prv *ecdsa.PrivateKey) *PrivateKey { |
||||
pub := ImportECDSAPublic(&prv.PublicKey) |
||||
return &PrivateKey{*pub, prv.D} |
||||
} |
||||
|
||||
// Generate an elliptic curve public / private keypair. If params is nil,
|
||||
// the recommended default paramters for the key will be chosen.
|
||||
func GenerateKey(rand io.Reader, curve elliptic.Curve, params *ECIESParams) (prv *PrivateKey, err error) { |
||||
pb, x, y, err := elliptic.GenerateKey(curve, rand) |
||||
if err != nil { |
||||
return |
||||
} |
||||
prv = new(PrivateKey) |
||||
prv.PublicKey.X = x |
||||
prv.PublicKey.Y = y |
||||
prv.PublicKey.Curve = curve |
||||
prv.D = new(big.Int).SetBytes(pb) |
||||
if params == nil { |
||||
params = ParamsFromCurve(curve) |
||||
} |
||||
prv.PublicKey.Params = params |
||||
return |
||||
} |
||||
|
||||
// MaxSharedKeyLength returns the maximum length of the shared key the
|
||||
// public key can produce.
|
||||
func MaxSharedKeyLength(pub *PublicKey) int { |
||||
return (pub.Curve.Params().BitSize + 7) / 8 |
||||
} |
||||
|
||||
// ECDH key agreement method used to establish secret keys for encryption.
|
||||
func (prv *PrivateKey) GenerateShared(pub *PublicKey, skLen, macLen int) (sk []byte, err error) { |
||||
if prv.PublicKey.Curve != pub.Curve { |
||||
err = ErrInvalidCurve |
||||
return |
||||
} |
||||
x, _ := pub.Curve.ScalarMult(pub.X, pub.Y, prv.D.Bytes()) |
||||
if x == nil || (x.BitLen()+7)/8 < (skLen+macLen) { |
||||
err = ErrSharedKeyTooBig |
||||
return |
||||
} |
||||
sk = x.Bytes()[:skLen+macLen] |
||||
return |
||||
} |
||||
|
||||
var ( |
||||
ErrKeyDataTooLong = fmt.Errorf("ecies: can't supply requested key data") |
||||
ErrSharedTooLong = fmt.Errorf("ecies: shared secret is too long") |
||||
ErrInvalidMessage = fmt.Errorf("ecies: invalid message") |
||||
) |
||||
|
||||
var ( |
||||
big2To32 = new(big.Int).Exp(big.NewInt(2), big.NewInt(32), nil) |
||||
big2To32M1 = new(big.Int).Sub(big2To32, big.NewInt(1)) |
||||
) |
||||
|
||||
func incCounter(ctr []byte) { |
||||
if ctr[3]++; ctr[3] != 0 { |
||||
return |
||||
} else if ctr[2]++; ctr[2] != 0 { |
||||
return |
||||
} else if ctr[1]++; ctr[1] != 0 { |
||||
return |
||||
} else if ctr[0]++; ctr[0] != 0 { |
||||
return |
||||
} |
||||
return |
||||
} |
||||
|
||||
// NIST SP 800-56 Concatenation Key Derivation Function (see section 5.8.1).
|
||||
func concatKDF(hash hash.Hash, z, s1 []byte, kdLen int) (k []byte, err error) { |
||||
if s1 == nil { |
||||
s1 = make([]byte, 0) |
||||
} |
||||
|
||||
reps := ((kdLen + 7) * 8) / (hash.BlockSize() * 8) |
||||
if big.NewInt(int64(reps)).Cmp(big2To32M1) > 0 { |
||||
fmt.Println(big2To32M1) |
||||
return nil, ErrKeyDataTooLong |
||||
} |
||||
|
||||
counter := []byte{0, 0, 0, 1} |
||||
k = make([]byte, 0) |
||||
|
||||
for i := 0; i <= reps; i++ { |
||||
hash.Write(counter) |
||||
hash.Write(z) |
||||
hash.Write(s1) |
||||
k = append(k, hash.Sum(nil)...) |
||||
hash.Reset() |
||||
incCounter(counter) |
||||
} |
||||
|
||||
k = k[:kdLen] |
||||
return |
||||
} |
||||
|
||||
// messageTag computes the MAC of a message (called the tag) as per
|
||||
// SEC 1, 3.5.
|
||||
func messageTag(hash func() hash.Hash, km, msg, shared []byte) []byte { |
||||
if shared == nil { |
||||
shared = make([]byte, 0) |
||||
} |
||||
mac := hmac.New(hash, km) |
||||
mac.Write(msg) |
||||
tag := mac.Sum(nil) |
||||
return tag |
||||
} |
||||
|
||||
// Generate an initialisation vector for CTR mode.
|
||||
func generateIV(params *ECIESParams, rand io.Reader) (iv []byte, err error) { |
||||
iv = make([]byte, params.BlockSize) |
||||
_, err = io.ReadFull(rand, iv) |
||||
return |
||||
} |
||||
|
||||
// symEncrypt carries out CTR encryption using the block cipher specified in the
|
||||
// parameters.
|
||||
func symEncrypt(rand io.Reader, params *ECIESParams, key, m []byte) (ct []byte, err error) { |
||||
c, err := params.Cipher(key) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
iv, err := generateIV(params, rand) |
||||
if err != nil { |
||||
return |
||||
} |
||||
ctr := cipher.NewCTR(c, iv) |
||||
|
||||
ct = make([]byte, len(m)+params.BlockSize) |
||||
copy(ct, iv) |
||||
ctr.XORKeyStream(ct[params.BlockSize:], m) |
||||
return |
||||
} |
||||
|
||||
// symDecrypt carries out CTR decryption using the block cipher specified in
|
||||
// the parameters
|
||||
func symDecrypt(rand io.Reader, params *ECIESParams, key, ct []byte) (m []byte, err error) { |
||||
c, err := params.Cipher(key) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
ctr := cipher.NewCTR(c, ct[:params.BlockSize]) |
||||
|
||||
m = make([]byte, len(ct)-params.BlockSize) |
||||
ctr.XORKeyStream(m, ct[params.BlockSize:]) |
||||
return |
||||
} |
||||
|
||||
// Encrypt encrypts a message using ECIES as specified in SEC 1, 5.1. If
|
||||
// the shared information parameters aren't being used, they should be
|
||||
// nil.
|
||||
func Encrypt(rand io.Reader, pub *PublicKey, m, s1, s2 []byte) (ct []byte, err error) { |
||||
params := pub.Params |
||||
if params == nil { |
||||
if params = ParamsFromCurve(pub.Curve); params == nil { |
||||
err = ErrUnsupportedECIESParameters |
||||
return |
||||
} |
||||
} |
||||
R, err := GenerateKey(rand, pub.Curve, params) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
hash := params.Hash() |
||||
z, err := R.GenerateShared(pub, params.KeyLen, params.KeyLen) |
||||
if err != nil { |
||||
return |
||||
} |
||||
K, err := concatKDF(hash, z, s1, params.KeyLen+params.KeyLen) |
||||
if err != nil { |
||||
return |
||||
} |
||||
Ke := K[:params.KeyLen] |
||||
Km := K[params.KeyLen:] |
||||
hash.Write(Km) |
||||
Km = hash.Sum(nil) |
||||
hash.Reset() |
||||
|
||||
em, err := symEncrypt(rand, params, Ke, m) |
||||
if err != nil || len(em) <= params.BlockSize { |
||||
return |
||||
} |
||||
|
||||
d := messageTag(params.Hash, Km, em, s2) |
||||
|
||||
Rb := elliptic.Marshal(pub.Curve, R.PublicKey.X, R.PublicKey.Y) |
||||
ct = make([]byte, len(Rb)+len(em)+len(d)) |
||||
copy(ct, Rb) |
||||
copy(ct[len(Rb):], em) |
||||
copy(ct[len(Rb)+len(em):], d) |
||||
return |
||||
} |
||||
|
||||
// Decrypt decrypts an ECIES ciphertext.
|
||||
func (prv *PrivateKey) Decrypt(rand io.Reader, c, s1, s2 []byte) (m []byte, err error) { |
||||
if c == nil || len(c) == 0 { |
||||
err = ErrInvalidMessage |
||||
return |
||||
} |
||||
params := prv.PublicKey.Params |
||||
if params == nil { |
||||
if params = ParamsFromCurve(prv.PublicKey.Curve); params == nil { |
||||
err = ErrUnsupportedECIESParameters |
||||
return |
||||
} |
||||
} |
||||
hash := params.Hash() |
||||
|
||||
var ( |
||||
rLen int |
||||
hLen int = hash.Size() |
||||
mStart int |
||||
mEnd int |
||||
) |
||||
|
||||
switch c[0] { |
||||
case 2, 3, 4: |
||||
rLen = ((prv.PublicKey.Curve.Params().BitSize + 7) / 4) |
||||
if len(c) < (rLen + hLen + 1) { |
||||
err = ErrInvalidMessage |
||||
return |
||||
} |
||||
default: |
||||
err = ErrInvalidPublicKey |
||||
return |
||||
} |
||||
|
||||
mStart = rLen |
||||
mEnd = len(c) - hLen |
||||
|
||||
R := new(PublicKey) |
||||
R.Curve = prv.PublicKey.Curve |
||||
R.X, R.Y = elliptic.Unmarshal(R.Curve, c[:rLen]) |
||||
if R.X == nil { |
||||
err = ErrInvalidPublicKey |
||||
return |
||||
} |
||||
|
||||
z, err := prv.GenerateShared(R, params.KeyLen, params.KeyLen) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
K, err := concatKDF(hash, z, s1, params.KeyLen+params.KeyLen) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
Ke := K[:params.KeyLen] |
||||
Km := K[params.KeyLen:] |
||||
hash.Write(Km) |
||||
Km = hash.Sum(nil) |
||||
hash.Reset() |
||||
|
||||
d := messageTag(params.Hash, Km, c[mStart:mEnd], s2) |
||||
if subtle.ConstantTimeCompare(c[mEnd:], d) != 1 { |
||||
err = ErrInvalidMessage |
||||
return |
||||
} |
||||
|
||||
m, err = symDecrypt(rand, params, Ke, c[mStart:mEnd]) |
||||
return |
||||
} |
||||
@ -1,489 +0,0 @@ |
||||
package ecies |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/elliptic" |
||||
"crypto/rand" |
||||
"crypto/sha256" |
||||
"flag" |
||||
"fmt" |
||||
"io/ioutil" |
||||
"testing" |
||||
) |
||||
|
||||
var dumpEnc bool |
||||
|
||||
func init() { |
||||
flDump := flag.Bool("dump", false, "write encrypted test message to file") |
||||
flag.Parse() |
||||
dumpEnc = *flDump |
||||
} |
||||
|
||||
// Ensure the KDF generates appropriately sized keys.
|
||||
func TestKDF(t *testing.T) { |
||||
msg := []byte("Hello, world") |
||||
h := sha256.New() |
||||
|
||||
k, err := concatKDF(h, msg, nil, 64) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
if len(k) != 64 { |
||||
fmt.Printf("KDF: generated key is the wrong size (%d instead of 64\n", |
||||
len(k)) |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
var skLen int |
||||
var ErrBadSharedKeys = fmt.Errorf("ecies: shared keys don't match") |
||||
|
||||
// cmpParams compares a set of ECIES parameters. We assume, as per the
|
||||
// docs, that AES is the only supported symmetric encryption algorithm.
|
||||
func cmpParams(p1, p2 *ECIESParams) bool { |
||||
if p1.hashAlgo != p2.hashAlgo { |
||||
return false |
||||
} else if p1.KeyLen != p2.KeyLen { |
||||
return false |
||||
} else if p1.BlockSize != p2.BlockSize { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// cmpPublic returns true if the two public keys represent the same pojnt.
|
||||
func cmpPublic(pub1, pub2 PublicKey) bool { |
||||
if pub1.X == nil || pub1.Y == nil { |
||||
fmt.Println(ErrInvalidPublicKey.Error()) |
||||
return false |
||||
} |
||||
if pub2.X == nil || pub2.Y == nil { |
||||
fmt.Println(ErrInvalidPublicKey.Error()) |
||||
return false |
||||
} |
||||
pub1Out := elliptic.Marshal(pub1.Curve, pub1.X, pub1.Y) |
||||
pub2Out := elliptic.Marshal(pub2.Curve, pub2.X, pub2.Y) |
||||
|
||||
return bytes.Equal(pub1Out, pub2Out) |
||||
} |
||||
|
||||
// cmpPrivate returns true if the two private keys are the same.
|
||||
func cmpPrivate(prv1, prv2 *PrivateKey) bool { |
||||
if prv1 == nil || prv1.D == nil { |
||||
return false |
||||
} else if prv2 == nil || prv2.D == nil { |
||||
return false |
||||
} else if prv1.D.Cmp(prv2.D) != 0 { |
||||
return false |
||||
} else { |
||||
return cmpPublic(prv1.PublicKey, prv2.PublicKey) |
||||
} |
||||
} |
||||
|
||||
// Validate the ECDH component.
|
||||
func TestSharedKey(t *testing.T) { |
||||
prv1, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
skLen = MaxSharedKeyLength(&prv1.PublicKey) / 2 |
||||
|
||||
prv2, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sk1, err := prv1.GenerateShared(&prv2.PublicKey, skLen, skLen) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sk2, err := prv2.GenerateShared(&prv1.PublicKey, skLen, skLen) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(sk1, sk2) { |
||||
fmt.Println(ErrBadSharedKeys.Error()) |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Verify that the key generation code fails when too much key data is
|
||||
// requested.
|
||||
func TestTooBigSharedKey(t *testing.T) { |
||||
prv1, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
prv2, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
_, err = prv1.GenerateShared(&prv2.PublicKey, skLen*2, skLen*2) |
||||
if err != ErrSharedKeyTooBig { |
||||
fmt.Println("ecdh: shared key should be too large for curve") |
||||
t.FailNow() |
||||
} |
||||
|
||||
_, err = prv2.GenerateShared(&prv1.PublicKey, skLen*2, skLen*2) |
||||
if err != ErrSharedKeyTooBig { |
||||
fmt.Println("ecdh: shared key should be too large for curve") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Ensure a public key can be successfully marshalled and unmarshalled, and
|
||||
// that the decoded key is the same as the original.
|
||||
func TestMarshalPublic(t *testing.T) { |
||||
prv, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
out, err := MarshalPublic(&prv.PublicKey) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
pub, err := UnmarshalPublic(out) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !cmpPublic(prv.PublicKey, *pub) { |
||||
fmt.Println("ecies: failed to unmarshal public key") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Ensure that a private key can be encoded into DER format, and that
|
||||
// the resulting key is properly parsed back into a public key.
|
||||
func TestMarshalPrivate(t *testing.T) { |
||||
prv, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
out, err := MarshalPrivate(prv) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if dumpEnc { |
||||
ioutil.WriteFile("test.out", out, 0644) |
||||
} |
||||
|
||||
prv2, err := UnmarshalPrivate(out) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !cmpPrivate(prv, prv2) { |
||||
fmt.Println("ecdh: private key import failed") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Ensure that a private key can be successfully encoded to PEM format, and
|
||||
// the resulting key is properly parsed back in.
|
||||
func TestPrivatePEM(t *testing.T) { |
||||
prv, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
out, err := ExportPrivatePEM(prv) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if dumpEnc { |
||||
ioutil.WriteFile("test.key", out, 0644) |
||||
} |
||||
|
||||
prv2, err := ImportPrivatePEM(out) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} else if !cmpPrivate(prv, prv2) { |
||||
fmt.Println("ecdh: import from PEM failed") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Ensure that a public key can be successfully encoded to PEM format, and
|
||||
// the resulting key is properly parsed back in.
|
||||
func TestPublicPEM(t *testing.T) { |
||||
prv, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
out, err := ExportPublicPEM(&prv.PublicKey) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if dumpEnc { |
||||
ioutil.WriteFile("test.pem", out, 0644) |
||||
} |
||||
|
||||
pub2, err := ImportPublicPEM(out) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} else if !cmpPublic(prv.PublicKey, *pub2) { |
||||
fmt.Println("ecdh: import from PEM failed") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// Benchmark the generation of P256 keys.
|
||||
func BenchmarkGenerateKeyP256(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
if _, err := GenerateKey(rand.Reader, elliptic.P256(), nil); err != nil { |
||||
fmt.Println(err.Error()) |
||||
b.FailNow() |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Benchmark the generation of P256 shared keys.
|
||||
func BenchmarkGenSharedKeyP256(b *testing.B) { |
||||
prv, err := GenerateKey(rand.Reader, elliptic.P256(), nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
b.FailNow() |
||||
} |
||||
|
||||
for i := 0; i < b.N; i++ { |
||||
_, err := prv.GenerateShared(&prv.PublicKey, skLen, skLen) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
b.FailNow() |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Verify that an encrypted message can be successfully decrypted.
|
||||
func TestEncryptDecrypt(t *testing.T) { |
||||
prv1, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
prv2, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
message := []byte("Hello, world.") |
||||
ct, err := Encrypt(rand.Reader, &prv2.PublicKey, message, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(pt, message) { |
||||
fmt.Println("ecies: plaintext doesn't match message") |
||||
t.FailNow() |
||||
} |
||||
|
||||
_, err = prv1.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err == nil { |
||||
fmt.Println("ecies: encryption should not have succeeded") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
|
||||
// TestMarshalEncryption validates the encode/decode produces a valid
|
||||
// ECIES encryption key.
|
||||
func TestMarshalEncryption(t *testing.T) { |
||||
prv1, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
out, err := MarshalPrivate(prv1) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
prv2, err := UnmarshalPrivate(out) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
message := []byte("Hello, world.") |
||||
ct, err := Encrypt(rand.Reader, &prv2.PublicKey, message, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(pt, message) { |
||||
fmt.Println("ecies: plaintext doesn't match message") |
||||
t.FailNow() |
||||
} |
||||
|
||||
_, err = prv1.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
} |
||||
|
||||
type testCase struct { |
||||
Curve elliptic.Curve |
||||
Name string |
||||
Expected bool |
||||
} |
||||
|
||||
var testCases = []testCase{ |
||||
testCase{ |
||||
Curve: elliptic.P224(), |
||||
Name: "P224", |
||||
Expected: false, |
||||
}, |
||||
testCase{ |
||||
Curve: elliptic.P256(), |
||||
Name: "P256", |
||||
Expected: true, |
||||
}, |
||||
testCase{ |
||||
Curve: elliptic.P384(), |
||||
Name: "P384", |
||||
Expected: true, |
||||
}, |
||||
testCase{ |
||||
Curve: elliptic.P521(), |
||||
Name: "P521", |
||||
Expected: true, |
||||
}, |
||||
} |
||||
|
||||
// Test parameter selection for each curve, and that P224 fails automatic
|
||||
// parameter selection (see README for a discussion of P224). Ensures that
|
||||
// selecting a set of parameters automatically for the given curve works.
|
||||
func TestParamSelection(t *testing.T) { |
||||
for _, c := range testCases { |
||||
testParamSelection(t, c) |
||||
} |
||||
} |
||||
|
||||
func testParamSelection(t *testing.T, c testCase) { |
||||
params := ParamsFromCurve(c.Curve) |
||||
if params == nil && c.Expected { |
||||
fmt.Printf("%s (%s)\n", ErrInvalidParams.Error(), c.Name) |
||||
t.FailNow() |
||||
} else if params != nil && !c.Expected { |
||||
fmt.Printf("ecies: parameters should be invalid (%s)\n", |
||||
c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
prv1, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Printf("%s (%s)\n", err.Error(), c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
prv2, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Printf("%s (%s)\n", err.Error(), c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
message := []byte("Hello, world.") |
||||
ct, err := Encrypt(rand.Reader, &prv2.PublicKey, message, nil, nil) |
||||
if err != nil { |
||||
fmt.Printf("%s (%s)\n", err.Error(), c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err != nil { |
||||
fmt.Printf("%s (%s)\n", err.Error(), c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(pt, message) { |
||||
fmt.Printf("ecies: plaintext doesn't match message (%s)\n", |
||||
c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
_, err = prv1.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err == nil { |
||||
fmt.Printf("ecies: encryption should not have succeeded (%s)\n", |
||||
c.Name) |
||||
t.FailNow() |
||||
} |
||||
|
||||
} |
||||
|
||||
// Ensure that the basic public key validation in the decryption operation
|
||||
// works.
|
||||
func TestBasicKeyValidation(t *testing.T) { |
||||
badBytes := []byte{0, 1, 5, 6, 7, 8, 9} |
||||
|
||||
prv, err := GenerateKey(rand.Reader, DefaultCurve, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
message := []byte("Hello, world.") |
||||
ct, err := Encrypt(rand.Reader, &prv.PublicKey, message, nil, nil) |
||||
if err != nil { |
||||
fmt.Println(err.Error()) |
||||
t.FailNow() |
||||
} |
||||
|
||||
for _, b := range badBytes { |
||||
ct[0] = b |
||||
_, err := prv.Decrypt(rand.Reader, ct, nil, nil) |
||||
if err != ErrInvalidPublicKey { |
||||
fmt.Println("ecies: validated an invalid key") |
||||
t.FailNow() |
||||
} |
||||
} |
||||
} |
||||
@ -1,187 +0,0 @@ |
||||
package ecies |
||||
|
||||
// This file contains parameters for ECIES encryption, specifying the
|
||||
// symmetric encryption and HMAC parameters.
|
||||
|
||||
import ( |
||||
"crypto" |
||||
"crypto/aes" |
||||
"crypto/cipher" |
||||
"crypto/elliptic" |
||||
"crypto/sha256" |
||||
"crypto/sha512" |
||||
"fmt" |
||||
"hash" |
||||
) |
||||
|
||||
// The default curve for this package is the NIST P256 curve, which
|
||||
// provides security equivalent to AES-128.
|
||||
var DefaultCurve = elliptic.P256() |
||||
|
||||
var ( |
||||
ErrUnsupportedECDHAlgorithm = fmt.Errorf("ecies: unsupported ECDH algorithm") |
||||
ErrUnsupportedECIESParameters = fmt.Errorf("ecies: unsupported ECIES parameters") |
||||
) |
||||
|
||||
type ECIESParams struct { |
||||
Hash func() hash.Hash // hash function
|
||||
hashAlgo crypto.Hash |
||||
Cipher func([]byte) (cipher.Block, error) // symmetric cipher
|
||||
BlockSize int // block size of symmetric cipher
|
||||
KeyLen int // length of symmetric key
|
||||
} |
||||
|
||||
// Standard ECIES parameters:
|
||||
// * ECIES using AES128 and HMAC-SHA-256-16
|
||||
// * ECIES using AES256 and HMAC-SHA-256-32
|
||||
// * ECIES using AES256 and HMAC-SHA-384-48
|
||||
// * ECIES using AES256 and HMAC-SHA-512-64
|
||||
var ( |
||||
ECIES_AES128_SHA256 *ECIESParams |
||||
ECIES_AES256_SHA256 *ECIESParams |
||||
ECIES_AES256_SHA384 *ECIESParams |
||||
ECIES_AES256_SHA512 *ECIESParams |
||||
) |
||||
|
||||
func init() { |
||||
ECIES_AES128_SHA256 = &ECIESParams{ |
||||
Hash: sha256.New, |
||||
hashAlgo: crypto.SHA256, |
||||
Cipher: aes.NewCipher, |
||||
BlockSize: aes.BlockSize, |
||||
KeyLen: 16, |
||||
} |
||||
|
||||
ECIES_AES256_SHA256 = &ECIESParams{ |
||||
Hash: sha256.New, |
||||
hashAlgo: crypto.SHA256, |
||||
Cipher: aes.NewCipher, |
||||
BlockSize: aes.BlockSize, |
||||
KeyLen: 32, |
||||
} |
||||
|
||||
ECIES_AES256_SHA384 = &ECIESParams{ |
||||
Hash: sha512.New384, |
||||
hashAlgo: crypto.SHA384, |
||||
Cipher: aes.NewCipher, |
||||
BlockSize: aes.BlockSize, |
||||
KeyLen: 32, |
||||
} |
||||
|
||||
ECIES_AES256_SHA512 = &ECIESParams{ |
||||
Hash: sha512.New, |
||||
hashAlgo: crypto.SHA512, |
||||
Cipher: aes.NewCipher, |
||||
BlockSize: aes.BlockSize, |
||||
KeyLen: 32, |
||||
} |
||||
} |
||||
|
||||
var paramsFromCurve = map[elliptic.Curve]*ECIESParams{ |
||||
elliptic.P256(): ECIES_AES128_SHA256, |
||||
elliptic.P384(): ECIES_AES256_SHA384, |
||||
elliptic.P521(): ECIES_AES256_SHA512, |
||||
} |
||||
|
||||
func AddParamsForCurve(curve elliptic.Curve, params *ECIESParams) { |
||||
paramsFromCurve[curve] = params |
||||
} |
||||
|
||||
// ParamsFromCurve selects parameters optimal for the selected elliptic curve.
|
||||
// Only the curves P256, P384, and P512 are supported.
|
||||
func ParamsFromCurve(curve elliptic.Curve) (params *ECIESParams) { |
||||
return paramsFromCurve[curve] |
||||
|
||||
/* |
||||
switch curve { |
||||
case elliptic.P256(): |
||||
return ECIES_AES128_SHA256 |
||||
case elliptic.P384(): |
||||
return ECIES_AES256_SHA384 |
||||
case elliptic.P521(): |
||||
return ECIES_AES256_SHA512 |
||||
default: |
||||
return nil |
||||
} |
||||
*/ |
||||
} |
||||
|
||||
// ASN.1 encode the ECIES parameters relevant to the encryption operations.
|
||||
func paramsToASNECIES(params *ECIESParams) (asnParams asnECIESParameters) { |
||||
if nil == params { |
||||
return |
||||
} |
||||
asnParams.KDF = asnNISTConcatenationKDF |
||||
asnParams.MAC = hmacFull |
||||
switch params.KeyLen { |
||||
case 16: |
||||
asnParams.Sym = aes128CTRinECIES |
||||
case 24: |
||||
asnParams.Sym = aes192CTRinECIES |
||||
case 32: |
||||
asnParams.Sym = aes256CTRinECIES |
||||
} |
||||
return |
||||
} |
||||
|
||||
// ASN.1 encode the ECIES parameters relevant to ECDH.
|
||||
func paramsToASNECDH(params *ECIESParams) (algo asnECDHAlgorithm) { |
||||
switch params.hashAlgo { |
||||
case crypto.SHA224: |
||||
algo = dhSinglePass_stdDH_sha224kdf |
||||
case crypto.SHA256: |
||||
algo = dhSinglePass_stdDH_sha256kdf |
||||
case crypto.SHA384: |
||||
algo = dhSinglePass_stdDH_sha384kdf |
||||
case crypto.SHA512: |
||||
algo = dhSinglePass_stdDH_sha512kdf |
||||
} |
||||
return |
||||
} |
||||
|
||||
// ASN.1 decode the ECIES parameters relevant to the encryption stage.
|
||||
func asnECIEStoParams(asnParams asnECIESParameters, params *ECIESParams) { |
||||
if !asnParams.KDF.Cmp(asnNISTConcatenationKDF) { |
||||
params = nil |
||||
return |
||||
} else if !asnParams.MAC.Cmp(hmacFull) { |
||||
params = nil |
||||
return |
||||
} |
||||
|
||||
switch { |
||||
case asnParams.Sym.Cmp(aes128CTRinECIES): |
||||
params.KeyLen = 16 |
||||
params.BlockSize = 16 |
||||
params.Cipher = aes.NewCipher |
||||
case asnParams.Sym.Cmp(aes192CTRinECIES): |
||||
params.KeyLen = 24 |
||||
params.BlockSize = 16 |
||||
params.Cipher = aes.NewCipher |
||||
case asnParams.Sym.Cmp(aes256CTRinECIES): |
||||
params.KeyLen = 32 |
||||
params.BlockSize = 16 |
||||
params.Cipher = aes.NewCipher |
||||
default: |
||||
params = nil |
||||
} |
||||
} |
||||
|
||||
// ASN.1 decode the ECIES parameters relevant to ECDH.
|
||||
func asnECDHtoParams(asnParams asnECDHAlgorithm, params *ECIESParams) { |
||||
if asnParams.Cmp(dhSinglePass_stdDH_sha224kdf) { |
||||
params.hashAlgo = crypto.SHA224 |
||||
params.Hash = sha256.New224 |
||||
} else if asnParams.Cmp(dhSinglePass_stdDH_sha256kdf) { |
||||
params.hashAlgo = crypto.SHA256 |
||||
params.Hash = sha256.New |
||||
} else if asnParams.Cmp(dhSinglePass_stdDH_sha384kdf) { |
||||
params.hashAlgo = crypto.SHA384 |
||||
params.Hash = sha512.New384 |
||||
} else if asnParams.Cmp(dhSinglePass_stdDH_sha512kdf) { |
||||
params.hashAlgo = crypto.SHA512 |
||||
params.Hash = sha512.New |
||||
} else { |
||||
params = nil |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
<html> |
||||
<head> |
||||
<script src="../ext/bignumber.min.js"></script> |
||||
<script src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
|
||||
<script> |
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8545')); |
||||
var eth = web3.eth; |
||||
|
||||
function bomb() { |
||||
for (var i = 0; i < 200; i++) { |
||||
eth.transact({}) |
||||
} |
||||
} |
||||
</script> |
||||
</head> |
||||
|
||||
<body> |
||||
<button onclick="bomb();">BOOM!</button> |
||||
</body> |
||||
</html> |
||||
@ -0,0 +1,34 @@ |
||||
package core |
||||
|
||||
import ( |
||||
"math/big" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/event" |
||||
) |
||||
|
||||
func proc() (*BlockProcessor, *ChainManager) { |
||||
db, _ := ethdb.NewMemDatabase() |
||||
var mux event.TypeMux |
||||
|
||||
chainMan := NewChainManager(db, &mux) |
||||
return NewBlockProcessor(db, nil, chainMan, &mux), chainMan |
||||
} |
||||
|
||||
func TestNumber(t *testing.T) { |
||||
bp, chain := proc() |
||||
block1 := chain.NewBlock(nil) |
||||
block1.Header().Number = big.NewInt(3) |
||||
|
||||
err := bp.ValidateBlock(block1, chain.Genesis()) |
||||
if err != BlockNumberErr { |
||||
t.Errorf("expected block number error") |
||||
} |
||||
|
||||
block1 = chain.NewBlock(nil) |
||||
err = bp.ValidateBlock(block1, chain.Genesis()) |
||||
if err == BlockNumberErr { |
||||
t.Errorf("didn't expect block number error") |
||||
} |
||||
} |
||||
@ -0,0 +1,181 @@ |
||||
package number |
||||
|
||||
import ( |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
) |
||||
|
||||
var tt256 = new(big.Int).Lsh(big.NewInt(1), 256) |
||||
var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1)) |
||||
var tt255 = new(big.Int).Lsh(big.NewInt(1), 255) |
||||
|
||||
func limitUnsigned256(x *Number) *Number { |
||||
x.num.And(x.num, tt256m1) |
||||
return x |
||||
} |
||||
|
||||
func limitSigned256(x *Number) *Number { |
||||
if x.num.Cmp(tt255) < 0 { |
||||
return x |
||||
} else { |
||||
x.num.Sub(x.num, tt256) |
||||
return x |
||||
} |
||||
} |
||||
|
||||
// Number function
|
||||
type Initialiser func(n int64) *Number |
||||
|
||||
// A Number represents a generic integer with a bounding function limiter. Limit is called after each operations
|
||||
// to give "fake" bounded integers. New types of Number can be created through NewInitialiser returning a lambda
|
||||
// with the new Initialiser.
|
||||
type Number struct { |
||||
num *big.Int |
||||
limit func(n *Number) *Number |
||||
} |
||||
|
||||
// Returns a new initialiser for a new *Number without having to expose certain fields
|
||||
func NewInitialiser(limiter func(*Number) *Number) Initialiser { |
||||
return func(n int64) *Number { |
||||
return &Number{big.NewInt(n), limiter} |
||||
} |
||||
} |
||||
|
||||
// Return a Number with a UNSIGNED limiter up to 256 bits
|
||||
func Uint256(n int64) *Number { |
||||
return &Number{big.NewInt(n), limitUnsigned256} |
||||
} |
||||
|
||||
// Return a Number with a SIGNED limiter up to 256 bits
|
||||
func Int256(n int64) *Number { |
||||
return &Number{big.NewInt(n), limitSigned256} |
||||
} |
||||
|
||||
// Returns a Number with a SIGNED unlimited size
|
||||
func Big(n int64) *Number { |
||||
return &Number{big.NewInt(n), func(x *Number) *Number { return x }} |
||||
} |
||||
|
||||
// Sets i to sum of x+y
|
||||
func (i *Number) Add(x, y *Number) *Number { |
||||
i.num.Add(x.num, y.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to difference of x-y
|
||||
func (i *Number) Sub(x, y *Number) *Number { |
||||
i.num.Sub(x.num, y.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to product of x*y
|
||||
func (i *Number) Mul(x, y *Number) *Number { |
||||
i.num.Mul(x.num, y.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to the quotient prodject of x/y
|
||||
func (i *Number) Div(x, y *Number) *Number { |
||||
i.num.Div(x.num, y.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to x % y
|
||||
func (i *Number) Mod(x, y *Number) *Number { |
||||
i.num.Mod(x.num, y.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to x << s
|
||||
func (i *Number) Lsh(x *Number, s uint) *Number { |
||||
i.num.Lsh(x.num, s) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Sets i to x^y
|
||||
func (i *Number) Pow(x, y *Number) *Number { |
||||
i.num.Exp(x.num, y.num, big.NewInt(0)) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Setters
|
||||
|
||||
// Set x to i
|
||||
func (i *Number) Set(x *Number) *Number { |
||||
i.num.Set(x.num) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Set x bytes to i
|
||||
func (i *Number) SetBytes(x []byte) *Number { |
||||
i.num.SetBytes(x) |
||||
return i.limit(i) |
||||
} |
||||
|
||||
// Cmp compares x and y and returns:
|
||||
//
|
||||
// -1 if x < y
|
||||
// 0 if x == y
|
||||
// +1 if x > y
|
||||
func (i *Number) Cmp(x *Number) int { |
||||
return i.num.Cmp(x.num) |
||||
} |
||||
|
||||
// Getters
|
||||
|
||||
// Returns the string representation of i
|
||||
func (i *Number) String() string { |
||||
return i.num.String() |
||||
} |
||||
|
||||
// Returns the byte representation of i
|
||||
func (i *Number) Bytes() []byte { |
||||
return i.num.Bytes() |
||||
} |
||||
|
||||
// Uint64 returns the Uint64 representation of x. If x cannot be represented in an int64, the result is undefined.
|
||||
func (i *Number) Uint64() uint64 { |
||||
return i.num.Uint64() |
||||
} |
||||
|
||||
// Int64 returns the int64 representation of x. If x cannot be represented in an int64, the result is undefined.
|
||||
func (i *Number) Int64() int64 { |
||||
return i.num.Int64() |
||||
} |
||||
|
||||
// Returns the signed version of i
|
||||
func (i *Number) Int256() *Number { |
||||
return Int(0).Set(i) |
||||
} |
||||
|
||||
// Returns the unsigned version of i
|
||||
func (i *Number) Uint256() *Number { |
||||
return Uint(0).Set(i) |
||||
} |
||||
|
||||
// Returns the index of the first bit that's set to 1
|
||||
func (i *Number) FirstBitSet() int { |
||||
for j := 0; j < i.num.BitLen(); j++ { |
||||
if i.num.Bit(j) > 0 { |
||||
return j |
||||
} |
||||
} |
||||
|
||||
return i.num.BitLen() |
||||
} |
||||
|
||||
// Variables
|
||||
|
||||
var ( |
||||
Zero = Uint(0) |
||||
One = Uint(1) |
||||
Two = Uint(2) |
||||
MaxUint256 = Uint(0).SetBytes(ethutil.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) |
||||
|
||||
MinOne = Int(-1) |
||||
|
||||
// "typedefs"
|
||||
Uint = Uint256 |
||||
Int = Int256 |
||||
) |
||||
@ -0,0 +1,92 @@ |
||||
package number |
||||
|
||||
import ( |
||||
"math/big" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
) |
||||
|
||||
func TestSet(t *testing.T) { |
||||
a := Uint(0) |
||||
b := Uint(10) |
||||
a.Set(b) |
||||
if a.num.Cmp(b.num) != 0 { |
||||
t.Error("didn't compare", a, b) |
||||
} |
||||
|
||||
c := Uint(0).SetBytes(ethutil.Hex2Bytes("0a")) |
||||
if c.num.Cmp(big.NewInt(10)) != 0 { |
||||
t.Error("c set bytes failed.") |
||||
} |
||||
} |
||||
|
||||
func TestInitialiser(t *testing.T) { |
||||
check := false |
||||
init := NewInitialiser(func(x *Number) *Number { |
||||
check = true |
||||
return x |
||||
}) |
||||
a := init(0).Add(init(1), init(2)) |
||||
if a.Cmp(init(3)) != 0 { |
||||
t.Error("expected 3. got", a) |
||||
} |
||||
if !check { |
||||
t.Error("expected limiter to be called") |
||||
} |
||||
} |
||||
|
||||
func TestGet(t *testing.T) { |
||||
a := Uint(10) |
||||
if a.Uint64() != 10 { |
||||
t.Error("expected to get 10. got", a.Uint64()) |
||||
} |
||||
|
||||
a = Uint(10) |
||||
if a.Int64() != 10 { |
||||
t.Error("expected to get 10. got", a.Int64()) |
||||
} |
||||
} |
||||
|
||||
func TestCmp(t *testing.T) { |
||||
a := Uint(10) |
||||
b := Uint(10) |
||||
c := Uint(11) |
||||
|
||||
if a.Cmp(b) != 0 { |
||||
t.Error("a b == 0 failed", a, b) |
||||
} |
||||
|
||||
if a.Cmp(c) >= 0 { |
||||
t.Error("a c < 0 failed", a, c) |
||||
} |
||||
|
||||
if c.Cmp(b) <= 0 { |
||||
t.Error("c b > 0 failed", c, b) |
||||
} |
||||
} |
||||
|
||||
func TestMaxArith(t *testing.T) { |
||||
a := Uint(0).Add(MaxUint256, One) |
||||
if a.Cmp(Zero) != 0 { |
||||
t.Error("expected max256 + 1 = 0 got", a) |
||||
} |
||||
|
||||
a = Uint(0).Sub(Uint(0), One) |
||||
if a.Cmp(MaxUint256) != 0 { |
||||
t.Error("expected 0 - 1 = max256 got", a) |
||||
} |
||||
|
||||
a = Int(0).Sub(Int(0), One) |
||||
if a.Cmp(MinOne) != 0 { |
||||
t.Error("expected 0 - 1 = -1 got", a) |
||||
} |
||||
} |
||||
|
||||
func TestConversion(t *testing.T) { |
||||
a := Int(-1) |
||||
b := a.Uint256() |
||||
if b.Cmp(MaxUint256) != 0 { |
||||
t.Error("expected -1 => unsigned to return max. got", b) |
||||
} |
||||
} |
||||
@ -0,0 +1,37 @@ |
||||
package rpc |
||||
|
||||
import ( |
||||
"sync" |
||||
"testing" |
||||
"time" |
||||
) |
||||
|
||||
func TestFilterClose(t *testing.T) { |
||||
api := &EthereumApi{ |
||||
logs: make(map[int]*logFilter), |
||||
messages: make(map[int]*whisperFilter), |
||||
quit: make(chan struct{}), |
||||
} |
||||
|
||||
filterTickerTime = 1 |
||||
api.logs[0] = &logFilter{} |
||||
api.messages[0] = &whisperFilter{} |
||||
var wg sync.WaitGroup |
||||
wg.Add(1) |
||||
go api.start() |
||||
go func() { |
||||
select { |
||||
case <-time.After(500 * time.Millisecond): |
||||
api.stop() |
||||
wg.Done() |
||||
} |
||||
}() |
||||
wg.Wait() |
||||
if len(api.logs) != 0 { |
||||
t.Error("expected logs to be empty") |
||||
} |
||||
|
||||
if len(api.messages) != 0 { |
||||
t.Error("expected messages to be empty") |
||||
} |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue