Common.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.
 
    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include <mutex>
#include <libdevcore/Address.h>
#include <libdevcore/Common.h>
#include <libdevcore/Exceptions.h>
#include <libdevcore/FixedHash.h>
 
namespace dev
{
 
using Secret = SecureFixedHash<32>;
 
using Public = h512;
 
using PublicCompressed = FixedHash<33>;
 
using Signature = h520;
 
struct SignatureStruct
{
    SignatureStruct() = default;
    SignatureStruct(Signature const& _s) { *(h520*)this = _s; }
    SignatureStruct(h256 const& _r, h256 const& _s, byte _v): r(_r), s(_s), v(_v) {}
    operator Signature() const { return *(h520 const*)this; }
 
    bool isValid() const noexcept;
 
    h256 r;
    h256 s;
    byte v = 0;
};
 
using Secrets = std::vector<Secret>;
 
Public toPublic(Secret const& _secret);
 
PublicCompressed toPublicCompressed(Secret const& _secret);
 
Address toAddress(Public const& _public);
 
Address toAddress(Secret const& _secret);
 
// Convert transaction from and nonce to address.
Address toAddress(Address const& _from, u256 const& _nonce);
 
void encrypt(Public const& _k, bytesConstRef _plain, bytes& o_cipher);
 
bool decrypt(Secret const& _k, bytesConstRef _cipher, bytes& o_plaintext);
 
void encryptSym(Secret const& _k, bytesConstRef _plain, bytes& o_cipher);
 
bool decryptSym(Secret const& _k, bytesConstRef _cipher, bytes& o_plaintext);
 
void encryptECIES(Public const& _k, bytesConstRef _plain, bytes& o_cipher);
 
void encryptECIES(Public const& _k, bytesConstRef _sharedMacData, bytesConstRef _plain, bytes& o_cipher);
 
bool decryptECIES(Secret const& _k, bytesConstRef _cipher, bytes& o_plaintext);
 
bool decryptECIES(Secret const& _k, bytesConstRef _sharedMacData, bytesConstRef _cipher, bytes& o_plaintext);
 
std::pair<bytes, h128> encryptSymNoAuth(SecureFixedHash<16> const& _k, bytesConstRef _plain);
 
bytes encryptAES128CTR(bytesConstRef _k, h128 const& _iv, bytesConstRef _plain);
 
bytesSec decryptAES128CTR(bytesConstRef _k, h128 const& _iv, bytesConstRef _cipher);
 
inline bytes encryptSymNoAuth(SecureFixedHash<16> const& _k, h128 const& _iv, bytesConstRef _plain) { return encryptAES128CTR(_k.ref(), _iv, _plain); }
inline bytes encryptSymNoAuth(SecureFixedHash<32> const& _k, h128 const& _iv, bytesConstRef _plain) { return encryptAES128CTR(_k.ref(), _iv, _plain); }
 
inline bytesSec decryptSymNoAuth(SecureFixedHash<16> const& _k, h128 const& _iv, bytesConstRef _cipher) { return decryptAES128CTR(_k.ref(), _iv, _cipher); }
inline bytesSec decryptSymNoAuth(SecureFixedHash<32> const& _k, h128 const& _iv, bytesConstRef _cipher) { return decryptAES128CTR(_k.ref(), _iv, _cipher); }
 
Public recover(Signature const& _sig, h256 const& _hash);
    
Signature sign(Secret const& _k, h256 const& _hash);
    
bool verify(Public const& _k, Signature const& _s, h256 const& _hash);
 
// Verify signature with compressed public key
bool verify(PublicCompressed const& _key, h512 const& _signature, h256 const& _hash);
 
bytesSec pbkdf2(std::string const& _pass, bytes const& _salt, unsigned _iterations, unsigned _dkLen = 32);
 
bytesSec scrypt(std::string const& _pass, bytes const& _salt, uint64_t _n, uint32_t _r, uint32_t _p, unsigned _dkLen);
 
class KeyPair
{
public:
    KeyPair(Secret const& _sec);
 
    static KeyPair create();
 
    static KeyPair fromEncryptedSeed(bytesConstRef _seed, std::string const& _password);
 
    Secret const& secret() const { return m_secret; }
 
    Public const& pub() const { return m_public; }
 
    Address const& address() const { return m_address; }
 
    bool operator==(KeyPair const& _c) const { return m_public == _c.m_public; }
    bool operator!=(KeyPair const& _c) const { return m_public != _c.m_public; }
 
private:
    Secret m_secret;
    Public m_public;
    Address m_address;
};
 
namespace crypto
{
 
DEV_SIMPLE_EXCEPTION(InvalidState);
 
h256 kdf(Secret const& _priv, h256 const& _hash);
 
class Nonce
{
public:
    static Secret get() { static Nonce s; return s.next(); }
 
private:
    Nonce() = default;
 
    Secret next();
 
    std::mutex x_value;
    Secret m_value;
};
 
namespace ecdh
{
 
bool agree(Secret const& _s, Public const& _r, Secret& o_s) noexcept;
 
}
 
namespace ecies
{
 
bytes kdf(Secret const& _z, bytes const& _s1, unsigned kdByteLen);
 
}
}
}