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 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);

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);

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);

}
}
}