Common.h

Go to the documentation of this file.

// Aleth: Ethereum C++ client, tools and libraries.
// Copyright 2014-2019 Aleth Authors.
// Licensed under the GNU General Public License, Version 3.
#pragma once
 
#include <libdevcore/Address.h>
#include <libdevcore/Common.h>
#include <libdevcore/Exceptions.h>
#include <libdevcore/FixedHash.h>
 
#include <mutex>
 
namespace dev {
 
using Secret = SecureFixedHash<32>;
 
using Public = h512;
 
using PublicCompressed = FixedHash<33>;
 
using Signature = h520;
 
using CompactSignature = h512;
 
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) {}
  SignatureStruct(const CompactSignature& _s) : SignatureStruct(Signature(_s)) {
    v = ::byte(u256(s) >> 255);
    s = u256(s) & ((u256(1) << 255) - 1);
  }
  operator Signature() const { return *reinterpret_cast<h520 const*>(this); }
 
  bool isValid() const noexcept;
 
  h256 r;
  h256 s;
  ::byte v = 0;
};
 
h512 toCompact(const Signature& _s);
 
struct CompactSignatureStruct {
  CompactSignatureStruct() = default;
  CompactSignatureStruct(const CompactSignature& _s) { *(h512*)this = _s; }
  CompactSignatureStruct(const Signature& _s) : CompactSignatureStruct(toCompact(_s)) {}
  CompactSignatureStruct(h256 const& _r, h256 const& _vs) : r(_r), vs(_vs) {}
  operator CompactSignature() const { return *reinterpret_cast<h512 const*>(this); }
 
  bool isValid() const noexcept;
 
  h256 r;
  h256 vs;
};
 
using Secrets = std::vector<Secret>;
 
Public toPublic(Secret const& _secret);
 
Public toPublic(PublicCompressed const& _publicCompressed);
 
PublicCompressed toPublicCompressed(Secret const& _secret);
 
Address toAddress(Public const& _public);
 
Address toAddress(Secret const& _secret);
 
void encrypt(Public const& _k, bytesConstRef _plain, bytes& o_cipher);
 
bool decrypt(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);
 
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);
 
}
}  // namespace crypto
}  // namespace dev