lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge remote-tracking branch 'upstream/develop' into newTests

cl-refactor
Christoph Jentzsch 10 years ago
parent
5a5a867eb3 cad2a1579c
commit
9564b3276e
20 changed files with 435 additions and 176 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      exp/main.cpp
  2. 16
      libdevcore/FixedHash.h
  3. 61
      libdevcrypto/Common.cpp
  4. 20
      libdevcrypto/Common.h
  5. 1
      libethcore/All.h
  6. 72
      libethereum/Transaction.cpp
  7. 9
      libethereum/Transaction.h
  8. 9
      libqethereum/QEthereum.cpp
  9. 30
      libqethereum/QEthereum.h
  10. 24
      libwhisper/Common.cpp
  11. 62
      libwhisper/Common.h
  12. 4
      libwhisper/Interface.cpp
  13. 39
      libwhisper/Interface.h
  14. 97
      libwhisper/Message.cpp
  15. 92
      libwhisper/Message.h
  16. 10
      libwhisper/WhisperHost.cpp
  17. 13
      libwhisper/WhisperHost.h
  18. 13
      libwhisper/WhisperPeer.cpp
  19. 2
      libwhisper/WhisperPeer.h
  20. 14
      stdserv.js

11
exp/main.cpp
View File

@ -95,23 +95,22 @@ int main(int argc, char** argv)
} }
Host ph("Test", NetworkPreferences(listenPort, "", false, true)); Host ph("Test", NetworkPreferences(listenPort, "", false, true));
ph.registerCapability(new WhisperHost()); auto wh = ph.registerCapability(new WhisperHost());
auto wh = ph.cap<WhisperHost>();
ph.start(); ph.start();
if (!remoteHost.empty()) if (!remoteHost.empty())
ph.connect(remoteHost, remotePort); ph.connect(remoteHost, remotePort);
/// Only interested in the packet if the lowest bit is 1 /// Only interested in odd packets
auto w = wh->installWatch(MessageFilter(TopicMasks({{Topic("0000000000000000000000000000000000000000000000000000000000000001"), Topic("0000000000000000000000000000000000000000000000000000000000000001")}}))); auto w = wh->installWatch(BuildTopicMask()("odd"));
for (int i = 0; ; ++i) for (int i = 0; ; ++i)
{ {
wh->sendRaw(RLPStream().append(i * i).out(), Topic(u256(i)), 1000); wh->sendRaw(RLPStream().append(i * i).out(), BuildTopic(i)(i % 2 ? "odd" : "even"));
for (auto i: wh->checkWatch(w)) for (auto i: wh->checkWatch(w))
{ {
auto p = wh->message(i).payload; auto p = wh->envelope(i).open().payload();
cnote << "New message:" << RLP(p).toInt<unsigned>(); cnote << "New message:" << RLP(p).toInt<unsigned>();
} }
} }

16
libdevcore/FixedHash.h
View File

@ -158,6 +158,21 @@ public:
return ret; return ret;
} }
/// Returns the index of the first bit set to one, or size() * 8 if no bits are set.
inline unsigned firstBitSet() const
{
unsigned ret = 0;
for (auto d: m_data)
if (d)
for (;; ++ret, d <<= 1)
if (d & 0x80)
return ret;
else {}
else
ret += 8;
return ret;
}
private: private:
std::array<byte, N> m_data; ///< The binary data. std::array<byte, N> m_data; ///< The binary data.
}; };
@ -193,6 +208,7 @@ inline std::ostream& operator<<(std::ostream& _out, FixedHash<N> const& _h)
} }
// Common types of FixedHash. // Common types of FixedHash.
using h520 = FixedHash<65>;
using h512 = FixedHash<64>; using h512 = FixedHash<64>;
using h256 = FixedHash<32>; using h256 = FixedHash<32>;
using h160 = FixedHash<20>; using h160 = FixedHash<20>;

61
libdevcrypto/Common.cpp
View File

@ -108,3 +108,64 @@ KeyPair KeyPair::fromEncryptedSeed(bytesConstRef _seed, std::string const& _pass
return KeyPair(sha3(aesDecrypt(_seed, _password))); return KeyPair(sha3(aesDecrypt(_seed, _password)));
} }
void dev::encrypt(Public _k, bytesConstRef _plain, bytes& _cipher)
{
(void)_k;
_cipher = _plain.toBytes();
}
bool dev::decrypt(Secret _k, bytesConstRef _cipher, bytes& _plain)
{
(void)_k;
_plain = _cipher.toBytes();
return true;
}
Public dev::recover(Signature _sig, h256 _message)
{
secp256k1_start();
byte pubkey[65];
int pubkeylen = 65;
if (!secp256k1_ecdsa_recover_compact(_message.data(), 32, _sig.data(), pubkey, &pubkeylen, 0, (int)_sig[64]))
return Public();
// right160(dev::sha3(bytesConstRef(&(pubkey[1]), 64)));
#if ETH_CRYPTO_TRACE
h256* sig = (h256 const*)_sig.data();
cout << "---- RECOVER -------------------------------" << endl;
cout << "MSG: " << _message << endl;
cout << "R S V: " << sig[0] << " " << sig[1] << " " << (int)(_sig[64] - 27) << "+27" << endl;
cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl;
#endif
return *(Public const*)&(pubkey[1]);
}
inline h256 kFromMessage(h256 _msg, h256 _priv)
{
return _msg ^ _priv;
}
Signature dev::sign(Secret _k, h256 _message)
{
int v = 0;
secp256k1_start();
SignatureStruct ret;
h256 nonce = kFromMessage(_message, _k);
if (!secp256k1_ecdsa_sign_compact(_message.data(), 32, ret.r.data(), _k.data(), nonce.data(), &v))
return Signature();
#if ETH_ADDRESS_DEBUG
cout << "---- SIGN -------------------------------" << endl;
cout << "MSG: " << _message << endl;
cout << "SEC: " << _k << endl;
cout << "NON: " << nonce << endl;
cout << "R S V: " << ret.r << " " << ret.s << " " << v << "+27" << endl;
#endif
ret.v = v;
return *(Signature const*)&ret;
}

20
libdevcrypto/Common.h
View File

@ -37,6 +37,12 @@ using Secret = h256;
/// @NOTE This is not endian-specific; it's just a bunch of bytes. /// @NOTE This is not endian-specific; it's just a bunch of bytes.
using Public = h512; using Public = h512;
/// A signature: 65 bytes: r: [0, 32), s: [32, 64), v: 64.
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
using Signature = h520;
struct SignatureStruct { h256 r; h256 s; byte v; };
/// An Ethereum address: 20 bytes. /// An Ethereum address: 20 bytes.
/// @NOTE This is not endian-specific; it's just a bunch of bytes. /// @NOTE This is not endian-specific; it's just a bunch of bytes.
using Address = h160; using Address = h160;
@ -44,9 +50,17 @@ using Address = h160;
/// A vector of Ethereum addresses. /// A vector of Ethereum addresses.
using Addresses = h160s; using Addresses = h160s;
/// Convert a private key into the public key equivalent. /// A vector of secrets.
/// @returns 0 if it's not a valid private key. using Secrets = h256s;
Address toAddress(h256 _private);
/// Convert a secret key into the public key equivalent.
/// @returns 0 if it's not a valid secret key.
Address toAddress(Secret _secret);
void encrypt(Public _k, bytesConstRef _plain, bytes& o_cipher);
bool decrypt(Secret _k, bytesConstRef _cipher, bytes& o_plain);
Public recover(Signature _sig, h256 _message);
Signature sign(Secret _k, h256 _message);
/// Simple class that represents a "key pair". /// Simple class that represents a "key pair".
/// All of the data of the class can be regenerated from the secret key (m_secret) alone. /// All of the data of the class can be regenerated from the secret key (m_secret) alone.

1
libethcore/All.h
View File

@ -3,6 +3,5 @@
#include "BlockInfo.h" #include "BlockInfo.h"
#include "CommonEth.h" #include "CommonEth.h"
#include "ProofOfWork.h" #include "ProofOfWork.h"
#include "CryptoHeaders.h"
#include "Exceptions.h" #include "Exceptions.h"

72
libethereum/Transaction.cpp
View File

@ -19,9 +19,9 @@
* @date 2014 * @date 2014
*/ */
#include <secp256k1/secp256k1.h>
#include <libdevcore/vector_ref.h> #include <libdevcore/vector_ref.h>
#include <libdevcore/Log.h> #include <libdevcore/Log.h>
#include <libdevcrypto/Common.h>
#include <libethcore/Exceptions.h> #include <libethcore/Exceptions.h>
#include "Transaction.h" #include "Transaction.h"
using namespace std; using namespace std;
@ -42,7 +42,7 @@ Transaction::Transaction(bytesConstRef _rlpData, bool _checkSender)
receiveAddress = rlp[field = 3].toHash<Address>(); receiveAddress = rlp[field = 3].toHash<Address>();
value = rlp[field = 4].toInt<u256>(); value = rlp[field = 4].toInt<u256>();
data = rlp[field = 5].toBytes(); data = rlp[field = 5].toBytes();
vrs = Signature{ rlp[field = 6].toInt<byte>(), rlp[field = 7].toInt<u256>(), rlp[field = 8].toInt<u256>() }; vrs = SignatureStruct{ rlp[field = 7].toInt<u256>(), rlp[field = 8].toInt<u256>(), byte(rlp[field = 6].toInt<byte>() - 27) };
if (_checkSender) if (_checkSender)
m_sender = sender(); m_sender = sender();
} }
@ -70,53 +70,18 @@ Address Transaction::sender() const
{ {
if (!m_sender) if (!m_sender)
{ {
secp256k1_start(); auto p = recover(*(Signature const*)&vrs, sha3(false));
if (!p)
h256 sig[2] = { vrs.r, vrs.s };
h256 msg = sha3(false);
byte pubkey[65];
int pubkeylen = 65;
if (!secp256k1_ecdsa_recover_compact(msg.data(), 32, sig[0].data(), pubkey, &pubkeylen, 0, (int)vrs.v - 27))
BOOST_THROW_EXCEPTION(InvalidSignature()); BOOST_THROW_EXCEPTION(InvalidSignature());
m_sender = right160(dev::sha3(bytesConstRef(p.data(), sizeof(p))));
// TODO: check right160 is correct and shouldn't be left160.
m_sender = right160(dev::sha3(bytesConstRef(&(pubkey[1]), 64)));
#if ETH_ADDRESS_DEBUG
cout << "---- RECOVER -------------------------------" << endl;
cout << "MSG: " << msg << endl;
cout << "R S V: " << sig[0] << " " << sig[1] << " " << (int)(vrs.v - 27) << "+27" << endl;
cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl;
cout << "ADR: " << m_sender << endl;
#endif
} }
return m_sender; return m_sender;
} }
void Transaction::sign(Secret _priv) void Transaction::sign(Secret _priv)
{ {
int v = 0; auto sig = dev::sign(_priv, sha3(false));
vrs = *(SignatureStruct const*)&sig;
secp256k1_start();
h256 msg = sha3(false);
h256 sig[2];
h256 nonce = kFromMessage(msg, _priv);
if (!secp256k1_ecdsa_sign_compact(msg.data(), 32, sig[0].data(), _priv.data(), nonce.data(), &v))
BOOST_THROW_EXCEPTION(InvalidSignature());
#if ETH_ADDRESS_DEBUG
cout << "---- SIGN -------------------------------" << endl;
cout << "MSG: " << msg << endl;
cout << "SEC: " << _priv << endl;
cout << "NON: " << nonce << endl;
cout << "R S V: " << sig[0] << " " << sig[1] << " " << v << "+27" << endl;
#endif
vrs.v = (byte)(v + 27);
vrs.r = (u256)sig[0];
vrs.s = (u256)sig[1];
} }
void Transaction::fillStream(RLPStream& _s, bool _sig) const void Transaction::fillStream(RLPStream& _s, bool _sig) const
@ -129,26 +94,5 @@ void Transaction::fillStream(RLPStream& _s, bool _sig) const
_s << ""; _s << "";
_s << value << data; _s << value << data;
if (_sig) if (_sig)
_s << vrs.v << vrs.r << vrs.s; _s << (vrs.v + 27) << (u256)vrs.r << (u256)vrs.s;
} }
// If the h256 return is an integer, store it in bigendian (i.e. u256 ret; ... return (h256)ret; )
h256 Transaction::kFromMessage(h256 _msg, h256 _priv)
{
// TODO!
// bytes v(32, 1);
// bytes k(32, 0);
/*
v = '\x01' * 32
k = '\x00' * 32
priv = encode_privkey(priv,'bin')
msghash = encode(hash_to_int(msghash),256,32)
k = hmac.new(k, v+'\x00'+priv+msghash, hashlib.sha256).digest()
v = hmac.new(k, v, hashlib.sha256).digest()
k = hmac.new(k, v+'\x01'+priv+msghash, hashlib.sha256).digest()
v = hmac.new(k, v, hashlib.sha256).digest()
return decode(hmac.new(k, v, hashlib.sha256).digest(),256)
*/
return _msg ^ _priv;
}

9
libethereum/Transaction.h
View File

@ -30,13 +30,6 @@ namespace dev
namespace eth namespace eth
{ {
struct Signature
{
byte v;
u256 r;
u256 s;
};
struct Transaction struct Transaction
{ {
Transaction() {} Transaction() {}
@ -54,7 +47,7 @@ struct Transaction
bytes data; ///< The data associated with the transaction, or the initialiser if it's a creation transaction. bytes data; ///< The data associated with the transaction, or the initialiser if it's a creation transaction.
Signature vrs; ///< The signature of the transaction. Encodes the sender. SignatureStruct vrs; ///< The signature of the transaction. Encodes the sender.
Address safeSender() const noexcept; ///< Like sender() but will never throw. Address safeSender() const noexcept; ///< Like sender() but will never throw.
Address sender() const; ///< Determine the sender of the transaction from the signature (and hash). Address sender() const; ///< Determine the sender of the transaction from the signature (and hash).

9
libqethereum/QEthereum.cpp
View File

@ -448,11 +448,10 @@ QString QEthereum::doTransact(QString _json)
TransactionSkeleton t = toTransaction(_json); TransactionSkeleton t = toTransaction(_json);
if (!t.from && m_accounts.size()) if (!t.from && m_accounts.size())
{ {
auto b = m_accounts.begin()->first; u256 b = 0;
for (auto a: m_accounts) for (auto a: m_accounts)
if (client()->balanceAt(a.first) > client()->balanceAt(b)) if (client()->balanceAt(a.first) > b)
b = a.first; t.from = a.first, b = client()->balanceAt(a.first);
t.from = b;
} }
if (!m_accounts.count(t.from)) if (!m_accounts.count(t.from))
return QString(); return QString();
@ -466,7 +465,7 @@ QString QEthereum::doTransact(QString _json)
// TODO: insert validification hook here. // TODO: insert validification hook here.
client()->transact(m_accounts[t.from].secret(), t.value, t.to, t.data, t.gas, t.gasPrice); client()->transact(m_accounts[t.from].secret(), t.value, t.to, t.data, t.gas, t.gasPrice);
else else
ret = toQJS(client()->transact(t.from, t.value, t.data, t.gas, t.gasPrice)); ret = toQJS(client()->transact(m_accounts[t.from].secret(), t.value, t.data, t.gas, t.gasPrice));
client()->flushTransactions(); client()->flushTransactions();
return ret; return ret;
} }

30
libqethereum/QEthereum.h
View File

@ -248,28 +248,30 @@ private:
}; };
// TODO: add p2p object // TODO: add p2p object
#define QETH_INSTALL_JS_NAMESPACE(_frame, _env, _dev, _eth, _shh) [_frame, _env, _dev, _eth, _shh]() \ #define QETH_INSTALL_JS_NAMESPACE(_frame, _env, _web3, _eth, _shh) [_frame, _env, _web3, _eth, _shh]() \
{ \ { \
_frame->disconnect(); \ _frame->disconnect(); \
_frame->addToJavaScriptWindowObject("env", _env, QWebFrame::QtOwnership); \ _frame->addToJavaScriptWindowObject("env", _env, QWebFrame::QtOwnership); \
_frame->addToJavaScriptWindowObject("dev", _dev, QWebFrame::ScriptOwnership); \ _frame->addToJavaScriptWindowObject("web3", _web3, QWebFrame::ScriptOwnership); \
if (_eth) \ if (_eth) \
{ \ { \
_frame->addToJavaScriptWindowObject("eth", _eth, QWebFrame::ScriptOwnership); \ _frame->addToJavaScriptWindowObject("_web3_dot_eth", _eth, QWebFrame::ScriptOwnership); \
_frame->evaluateJavaScript("eth.makeWatch = function(a) { var ww = eth.newWatch(a); var ret = { w: ww }; ret.uninstall = function() { eth.killWatch(w); }; ret.changed = function(f) { eth.watchChanged.connect(function(nw) { if (nw == ww) f() }); }; ret.messages = function() { return JSON.parse(eth.watchMessages(this.w)) }; return ret; }"); \ _frame->evaluateJavaScript("_web3_dot_eth.makeWatch = function(a) { var ww = _web3_dot_eth.newWatch(a); var ret = { w: ww }; ret.uninstall = function() { _web3_dot_eth.killWatch(w); }; ret.changed = function(f) { _web3_dot_eth.watchChanged.connect(function(nw) { if (nw == ww) f() }); }; ret.messages = function() { return JSON.parse(_web3_dot_eth.watchMessages(this.w)) }; return ret; }"); \
_frame->evaluateJavaScript("eth.watch = function(a) { return eth.makeWatch(JSON.stringify(a)) }"); \ _frame->evaluateJavaScript("_web3_dot_eth.watch = function(a) { return _web3_dot_eth.makeWatch(JSON.stringify(a)) }"); \
_frame->evaluateJavaScript("eth.transact = function(a, f) { var r = eth.doTransact(JSON.stringify(a)); if (f) f(r); }"); \ _frame->evaluateJavaScript("_web3_dot_eth.transact = function(a, f) { var r = _web3_dot_eth.doTransact(JSON.stringify(a)); if (f) f(r); }"); \
_frame->evaluateJavaScript("eth.call = function(a, f) { var ret = eth.doCallJson(JSON.stringify(a)); if (f) f(ret); return ret; }"); \ _frame->evaluateJavaScript("_web3_dot_eth.call = function(a, f) { var ret = _web3_dot_eth.doCallJson(JSON.stringify(a)); if (f) f(ret); return ret; }"); \
_frame->evaluateJavaScript("eth.messages = function(a) { return JSON.parse(eth.getMessages(JSON.stringify(a))); }"); \ _frame->evaluateJavaScript("_web3_dot_eth.messages = function(a) { return JSON.parse(_web3_dot_eth.getMessages(JSON.stringify(a))); }"); \
_frame->evaluateJavaScript("eth.block = function(a) { return JSON.parse(eth.getBlock(a)); }"); \ _frame->evaluateJavaScript("_web3_dot_eth.block = function(a) { return JSON.parse(_web3_dot_eth.getBlock(a)); }"); \
_frame->evaluateJavaScript("eth.transaction = function(a) { return JSON.parse(eth.getTransaction(a)); }"); \ _frame->evaluateJavaScript("_web3_dot_eth.transaction = function(a) { return JSON.parse(_web3_dot_eth.getTransaction(a)); }"); \
_frame->evaluateJavaScript("eth.uncle = function(a) { return JSON.parse(eth.getUncle(a)); }"); \ _frame->evaluateJavaScript("_web3_dot_eth.uncle = function(a) { return JSON.parse(_web3_dot_eth.getUncle(a)); }"); \
_frame->evaluateJavaScript("web3.eth = _web3_dot_eth"); \
} \ } \
if (_shh) \ if (_shh) \
{ \ { \
_frame->addToJavaScriptWindowObject("shh", _shh, QWebFrame::ScriptOwnership); \ _frame->addToJavaScriptWindowObject("_web3_dot_shh", _shh, QWebFrame::ScriptOwnership); \
_frame->evaluateJavaScript("shh.makeWatch = function(a) { var ww = shh.newWatch(a); var ret = { w: ww }; ret.uninstall = function() { shh.killWatch(w); }; ret.changed = function(f) { shh.watchChanged.connect(function(nw) { if (nw == ww) f() }); }; ret.messages = function() { return JSON.parse(shh.watchMessages(this.w)) }; return ret; }"); \ _frame->evaluateJavaScript("_web3_dot_shh.makeWatch = function(a) { var ww = _web3_dot_shh.newWatch(a); var ret = { w: ww }; ret.uninstall = function() { _web3_dot_shh.killWatch(w); }; ret.changed = function(f) { _web3_dot_shh.watchChanged.connect(function(nw) { if (nw == ww) f() }); }; ret.messages = function() { return JSON.parse(_web3_dot_shh.watchMessages(this.w)) }; return ret; }"); \
_frame->evaluateJavaScript("shh.watch = function(a) { return shh.makeWatch(JSON.stringify(a)) }"); \ _frame->evaluateJavaScript("_web3_dot_shh.watch = function(a) { return _web3_dot_shh.makeWatch(JSON.stringify(a)) }"); \
_frame->evaluateJavaScript("web3.shh = _web3_dot_shh"); \
} \ } \
} }

24
libwhisper/Common.cpp
View File

@ -21,8 +21,32 @@
#include "Common.h" #include "Common.h"
#include <libdevcrypto/SHA3.h>
using namespace std; using namespace std;
using namespace dev; using namespace dev;
using namespace dev::p2p; using namespace dev::p2p;
using namespace dev::shh; using namespace dev::shh;
BuildTopic& BuildTopic::shiftBytes(bytes const& _b)
{
m_parts.push_back(dev::sha3(_b));
return *this;
}
h256 TopicFilter::sha3() const
{
RLPStream s;
fillStream(s);
return dev::sha3(s.out());
}
TopicMask BuildTopicMask::toTopicMask() const
{
TopicMask ret;
for (auto i = 0; i < 32; ++i)
{
ret.first[i] = m_parts[i * m_parts.size() / 32][i];
ret.second[i] = m_parts[i * m_parts.size() / 32] ? 255 : 0;
}
return ret;
}

62
libwhisper/Common.h
View File

@ -25,7 +25,7 @@
#include <chrono> #include <chrono>
#include <libdevcore/Common.h> #include <libdevcore/Common.h>
#include <libdevcore/Log.h> #include <libdevcore/Log.h>
#include <libethcore/CommonEth.h> #include <libdevcore/RLP.h>
#include <libp2p/Capability.h> #include <libp2p/Capability.h>
namespace dev namespace dev
@ -48,6 +48,8 @@ class WhisperHost;
class WhisperPeer; class WhisperPeer;
class Whisper; class Whisper;
class Envelope;
enum WhisperPacket enum WhisperPacket
{ {
StatusPacket = 0, StatusPacket = 0,
@ -59,5 +61,63 @@ enum WhisperPacket
using Topic = h256; using Topic = h256;
class BuildTopic
{
public:
template <class T> BuildTopic(T const& _t) { shift(_t); }
template <class T> BuildTopic& shift(T const& _r) { return shiftBytes(RLPStream().append(_r).out()); }
template <class T> BuildTopic& operator()(T const& _t) { return shift(_t); }
BuildTopic& shiftRaw(h256 const& _part) { m_parts.push_back(_part); return *this; }
operator Topic() const { return toTopic(); }
Topic toTopic() const { Topic ret; for (auto i = 0; i < 32; ++i) ret[i] = m_parts[i * m_parts.size() / 32][i]; return ret; }
protected:
BuildTopic() {}
BuildTopic& shiftBytes(bytes const& _b);
h256s m_parts;
};
using TopicMask = std::pair<Topic, Topic>;
using TopicMasks = std::vector<TopicMask>;
class TopicFilter
{
public:
TopicFilter() {}
TopicFilter(TopicMask const& _m): m_topicMasks(1, _m) {}
TopicFilter(TopicMasks const& _m): m_topicMasks(_m) {}
TopicFilter(RLP const& _r): m_topicMasks((TopicMasks)_r) {}
void fillStream(RLPStream& _s) const { _s << m_topicMasks; }
h256 sha3() const;
bool matches(Envelope const& _m) const;
private:
TopicMasks m_topicMasks;
};
class BuildTopicMask: BuildTopic
{
public:
BuildTopicMask() { shift(); }
template <class T> BuildTopicMask(T const& _t) { shift(_t); }
template <class T> BuildTopicMask& shift(T const& _r) { BuildTopic::shift(_r); return *this; }
BuildTopicMask& shiftRaw(h256 const& _h) { BuildTopic::shiftRaw(_h); return *this; }
BuildTopic& shift() { m_parts.push_back(h256()); return *this; }
BuildTopicMask& operator()() { shift(); return *this; }
template <class T> BuildTopicMask& operator()(T const& _t) { shift(_t); return *this; }
operator TopicMask() const { return toTopicMask(); }
TopicMask toTopicMask() const;
};
} }
} }

4
libwhisper/Interface.cpp
View File

@ -34,10 +34,10 @@ using namespace dev::shh;
#endif #endif
#define clogS(X) dev::LogOutputStream<X, true>(false) << "| " << std::setw(2) << session()->socketId() << "] " #define clogS(X) dev::LogOutputStream<X, true>(false) << "| " << std::setw(2) << session()->socketId() << "] "
bool MessageFilter::matches(Message const& _m) const bool TopicFilter::matches(Envelope const& _e) const
{ {
for (TopicMask const& t: m_topicMasks) for (TopicMask const& t: m_topicMasks)
if (((t.first ^ _m.topic) & t.second) == 0) if (((t.first ^ _e.topic()) & t.second) == 0)
return true; return true;
return false; return false;
} }

39
libwhisper/Interface.h
View File

@ -43,30 +43,11 @@ namespace shh
Topic mask; Topic mask;
};*/ };*/
using TopicMask = std::pair<Topic, Topic>;
using TopicMasks = std::vector<TopicMask>;
class MessageFilter
{
public:
MessageFilter() {}
MessageFilter(TopicMasks const& _m): m_topicMasks(_m) {}
MessageFilter(RLP const& _r): m_topicMasks((TopicMasks)_r) {}
void fillStream(RLPStream& _s) const { _s << m_topicMasks; }
h256 sha3() const { RLPStream s; fillStream(s); return dev::sha3(s.out()); }
bool matches(Message const& _m) const;
private:
TopicMasks m_topicMasks;
};
struct InstalledFilter struct InstalledFilter
{ {
InstalledFilter(MessageFilter const& _f): filter(_f) {} InstalledFilter(TopicFilter const& _f): filter(_f) {}
MessageFilter filter; TopicFilter filter;
unsigned refCount = 1; unsigned refCount = 1;
}; };
@ -84,17 +65,21 @@ class Interface
public: public:
virtual ~Interface() {} virtual ~Interface() {}
virtual void inject(Message const& _m, WhisperPeer* _from = nullptr) = 0; virtual void inject(Envelope const& _m, WhisperPeer* _from = nullptr) = 0;
virtual unsigned installWatch(MessageFilter const& _filter) = 0; unsigned installWatch(TopicMask const& _mask) { return installWatch(TopicFilter(_mask)); }
virtual unsigned installWatch(h256 _filterId) = 0; virtual unsigned installWatch(TopicFilter const& _filter) = 0;
virtual unsigned installWatchOnId(h256 _filterId) = 0;
virtual void uninstallWatch(unsigned _watchId) = 0; virtual void uninstallWatch(unsigned _watchId) = 0;
virtual h256s peekWatch(unsigned _watchId) const = 0; virtual h256s peekWatch(unsigned _watchId) const = 0;
virtual h256s checkWatch(unsigned _watchId) = 0; virtual h256s checkWatch(unsigned _watchId) = 0;
virtual Message message(h256 _m) const = 0; virtual Envelope envelope(h256 _m) const = 0;
virtual void sendRaw(bytes const& _payload, h256 _topic, unsigned _ttl) = 0; void sendRaw(bytes const& _payload, Topic _topic, unsigned _ttl = 50, unsigned _workToProve = 50) { inject(Message(_payload).seal(_topic, _ttl, _workToProve)); }
void sendRaw(Public _to, bytes const& _payload, Topic _topic, unsigned _ttl = 50, unsigned _workToProve = 50) { inject(Message(_payload).seal(_to, _topic, _ttl, _workToProve)); }
void sendRaw(Secret _from, bytes const& _payload, Topic _topic, unsigned _ttl = 50, unsigned _workToProve = 50) { inject(Message(_payload).seal(_from, _topic, _ttl, _workToProve)); }
void sendRaw(Secret _from, Public _to, bytes const& _payload, Topic _topic, unsigned _ttl = 50, unsigned _workToProve = 50) { inject(Message(_payload).seal(_from, _to, _topic, _ttl, _workToProve)); }
}; };
struct WatshhChannel: public dev::LogChannel { static const char* name() { return "shh"; } static const int verbosity = 1; }; struct WatshhChannel: public dev::LogChannel { static const char* name() { return "shh"; } static const int verbosity = 1; };
@ -115,7 +100,7 @@ class Watch: public boost::noncopyable
public: public:
Watch() {} Watch() {}
Watch(Whisper& _c, h256 _f): m_c(&_c), m_id(_c.installWatch(_f)) {} Watch(Whisper& _c, h256 _f): m_c(&_c), m_id(_c.installWatch(_f)) {}
Watch(Whisper& _c, MessageFilter const& _tf): m_c(&_c), m_id(_c.installWatch(_tf)) {} Watch(Whisper& _c, TopicFilter const& _tf): m_c(&_c), m_id(_c.installWatch(_tf)) {}
~Watch() { if (m_c) m_c->uninstallWatch(m_id); } ~Watch() { if (m_c) m_c->uninstallWatch(m_id); }
bool check() { return m_c ? m_c->checkWatch(m_id) : false; } bool check() { return m_c ? m_c->checkWatch(m_id) : false; }

97
libwhisper/Message.cpp
View File

@ -25,3 +25,100 @@ using namespace std;
using namespace dev; using namespace dev;
using namespace dev::p2p; using namespace dev::p2p;
using namespace dev::shh; using namespace dev::shh;
Message::Message(Envelope const& _e, Secret const& _s)
{
try
{
bytes b;
if (_s)
decrypt(_s, &(_e.data()), b);
populate(_s ? b : _e.data());
m_to = KeyPair(_s).pub();
}
catch (...) // Invalid secret? TODO: replace ... with InvalidSecret
{
}
}
void Message::populate(bytes const& _data)
{
if (!_data.size())
return;
byte flags = _data[0];
if (!!(flags & ContainsSignature) && _data.size() > sizeof(Signature) + 1) // has a signature
{
bytesConstRef payload = bytesConstRef(&_data).cropped(sizeof(Signature) + 1);
h256 h = sha3(payload);
m_from = recover(*(Signature const*)&(_data[1]), h);
m_payload = payload.toBytes();
}
else
m_payload = bytesConstRef(&_data).cropped(1).toBytes();
}
Envelope Message::seal(Secret _from, Topic const& _topic, unsigned _ttl, unsigned _workToProve)
{
Envelope ret(time(0) + _ttl, _ttl, _topic);
bytes input(1 + m_payload.size());
input[0] = 0;
memcpy(input.data() + 1, m_payload.data(), m_payload.size());
if (_from) // needs a sig
{
input.resize(1 + m_payload.size() + sizeof(Signature));
input[0] |= ContainsSignature;
*(Signature*)&(input[1 + m_payload.size()]) = sign(_from, sha3(m_payload));
}
if (m_to)
encrypt(m_to, &input, ret.m_data);
else
swap(ret.m_data, input);
ret.proveWork(_workToProve);
return ret;
}
Message Envelope::open(Secret const& _s) const
{
return Message(*this, _s);
}
Message Envelope::open() const
{
return Message(*this);
}
unsigned Envelope::workProved() const
{
h256 d[2];
d[0] = sha3NoNonce();
d[1] = m_nonce;
return dev::sha3(bytesConstRef(d[0].data(), 64)).firstBitSet();
}
void Envelope::proveWork(unsigned _ms)
{
// PoW
h256 d[2];
d[0] = sha3NoNonce();
uint32_t& n = *(uint32_t*)&(d[1][28]);
unsigned bestBitSet = 0;
bytesConstRef chuck(d[0].data(), 64);
chrono::high_resolution_clock::time_point then = chrono::high_resolution_clock::now() + chrono::milliseconds(_ms);
for (n = 0; chrono::high_resolution_clock::now() < then; )
// do it rounds of 1024 for efficiency
for (unsigned i = 0; i < 1024; ++i, ++n)
{
auto fbs = dev::sha3(chuck).firstBitSet();
if (fbs > bestBitSet)
{
bestBitSet = fbs;
m_nonce = n;
}
}
}

92
libwhisper/Message.h
View File

@ -36,27 +36,89 @@ namespace dev
namespace shh namespace shh
{ {
struct Message class Message;
class Envelope
{ {
unsigned expiry = 0; friend class Message;
unsigned ttl = 0;
Topic topic; // TODO: change to h256
bytes payload;
Message() {} public:
Message(unsigned _exp, unsigned _ttl, Topic const& _topic, bytes const& _payload): expiry(_exp), ttl(_ttl), topic(_topic), payload(_payload) {} Envelope() {}
Message(RLP const& _m) Envelope(RLP const& _m)
{ {
expiry = _m[0].toInt<unsigned>(); m_expiry = _m[0].toInt<unsigned>();
ttl = _m[1].toInt<unsigned>(); m_ttl = _m[1].toInt<unsigned>();
topic = (Topic)_m[2]; m_topic = (Topic)_m[2];
payload = _m[3].toBytes(); m_data = _m[3].toBytes();
m_nonce = _m[4].toInt<u256>();
} }
operator bool () const { return !!expiry; } operator bool() const { return !!m_expiry; }
void streamOut(RLPStream& _s, bool _withNonce) const { _s.appendList(_withNonce ? 5 : 4) << m_expiry << m_ttl << m_topic << m_data; if (_withNonce) _s << m_nonce; }
h256 sha3() const { RLPStream s; streamOut(s, true); return dev::sha3(s.out()); }
h256 sha3NoNonce() const { RLPStream s; streamOut(s, false); return dev::sha3(s.out()); }
unsigned sent() const { return m_expiry - m_ttl; }
unsigned expiry() const { return m_expiry; }
unsigned ttl() const { return m_ttl; }
Topic const& topic() const { return m_topic; }
bytes const& data() const { return m_data; }
Message open(Secret const& _s) const;
Message open() const;
unsigned workProved() const;
void proveWork(unsigned _ms);
private:
Envelope(unsigned _exp, unsigned _ttl, Topic const& _topic): m_expiry(_exp), m_ttl(_ttl), m_topic(_topic) {}
unsigned m_expiry = 0;
unsigned m_ttl = 0;
u256 m_nonce;
Topic m_topic;
bytes m_data;
};
enum /*Message Flags*/
{
ContainsSignature = 0
};
/// An (unencrypted) message, constructed from the combination of an Envelope, and, potentially,
/// a Secret key to decrypt the Message.
class Message
{
public:
Message() {}
Message(Envelope const& _e, Secret const& _s = Secret());
Message(bytes const& _payload): m_payload(_payload) {}
Message(bytesConstRef _payload): m_payload(_payload.toBytes()) {}
Message(bytes&& _payload) { std::swap(_payload, m_payload); }
Public from() const { return m_from; }
Public to() const { return m_to; }
bytes const& payload() const { return m_payload; }
void setTo(Public _to) { m_to = _to; }
operator bool() const { return !!m_payload.size() || m_from || m_to; }
/// Turn this message into a ditributable Envelope.
Envelope seal(Secret _from, Topic const& _topic, unsigned _workToProve = 50, unsigned _ttl = 50);
// Overloads for skipping _from or specifying _to.
Envelope seal(Topic const& _topic, unsigned _ttl = 50, unsigned _workToProve = 50) { return seal(Secret(), _topic, _workToProve, _ttl); }
Envelope seal(Public _to, Topic const& _topic, unsigned _workToProve = 50, unsigned _ttl = 50) { m_to = _to; return seal(Secret(), _topic, _workToProve, _ttl); }
Envelope seal(Secret _from, Public _to, Topic const& _topic, unsigned _workToProve = 50, unsigned _ttl = 50) { m_to = _to; return seal(_from, _topic, _workToProve, _ttl); }
private:
void populate(bytes const& _data);
void streamOut(RLPStream& _s) const { _s.appendList(4) << expiry << ttl << topic << payload; } Public m_from;
h256 sha3() const { RLPStream s; streamOut(s); return dev::sha3(s.out()); } Public m_to;
bytes m_payload;
}; };
} }

10
libwhisper/WhisperHost.cpp
View File

@ -47,11 +47,11 @@ void WhisperHost::streamMessage(h256 _m, RLPStream& _s) const
if (m_messages.count(_m)) if (m_messages.count(_m))
{ {
UpgradeGuard ll(l); UpgradeGuard ll(l);
m_messages.at(_m).streamOut(_s); m_messages.at(_m).streamOut(_s, true);
} }
} }
void WhisperHost::inject(Message const& _m, WhisperPeer* _p) void WhisperHost::inject(Envelope const& _m, WhisperPeer* _p)
{ {
auto h = _m.sha3(); auto h = _m.sha3();
{ {
@ -87,7 +87,7 @@ void WhisperHost::noteChanged(h256 _messageHash, h256 _filter)
} }
} }
unsigned WhisperHost::installWatch(h256 _h) unsigned WhisperHost::installWatchOnId(h256 _h)
{ {
auto ret = m_watches.size() ? m_watches.rbegin()->first + 1 : 0; auto ret = m_watches.size() ? m_watches.rbegin()->first + 1 : 0;
m_watches[ret] = ClientWatch(_h); m_watches[ret] = ClientWatch(_h);
@ -95,7 +95,7 @@ unsigned WhisperHost::installWatch(h256 _h)
return ret; return ret;
} }
unsigned WhisperHost::installWatch(shh::MessageFilter const& _f) unsigned WhisperHost::installWatch(shh::TopicFilter const& _f)
{ {
Guard l(m_filterLock); Guard l(m_filterLock);
@ -104,7 +104,7 @@ unsigned WhisperHost::installWatch(shh::MessageFilter const& _f)
if (!m_filters.count(h)) if (!m_filters.count(h))
m_filters.insert(make_pair(h, _f)); m_filters.insert(make_pair(h, _f));
return installWatch(h); return installWatchOnId(h);
} }
void WhisperHost::uninstallWatch(unsigned _i) void WhisperHost::uninstallWatch(unsigned _i)

13
libwhisper/WhisperHost.h
View File

@ -48,17 +48,16 @@ public:
unsigned protocolVersion() const { return 0; } unsigned protocolVersion() const { return 0; }
virtual void inject(Message const& _m, WhisperPeer* _from = nullptr); virtual void inject(Envelope const& _e, WhisperPeer* _from = nullptr);
virtual unsigned installWatch(MessageFilter const& _filter); using Interface::installWatch;
virtual unsigned installWatch(h256 _filterId); virtual unsigned installWatch(TopicFilter const& _filter);
virtual unsigned installWatchOnId(h256 _filterId);
virtual void uninstallWatch(unsigned _watchId); virtual void uninstallWatch(unsigned _watchId);
virtual h256s peekWatch(unsigned _watchId) const { dev::Guard l(m_filterLock); try { return m_watches.at(_watchId).changes; } catch (...) { return h256s(); } } virtual h256s peekWatch(unsigned _watchId) const { dev::Guard l(m_filterLock); try { return m_watches.at(_watchId).changes; } catch (...) { return h256s(); } }
virtual h256s checkWatch(unsigned _watchId) { dev::Guard l(m_filterLock); h256s ret; try { ret = m_watches.at(_watchId).changes; m_watches.at(_watchId).changes.clear(); } catch (...) {} return ret; } virtual h256s checkWatch(unsigned _watchId) { dev::Guard l(m_filterLock); h256s ret; try { ret = m_watches.at(_watchId).changes; m_watches.at(_watchId).changes.clear(); } catch (...) {} return ret; }
virtual Message message(h256 _m) const { try { dev::ReadGuard l(x_messages); return m_messages.at(_m); } catch (...) { return Message(); } } virtual Envelope envelope(h256 _m) const { try { dev::ReadGuard l(x_messages); return m_messages.at(_m); } catch (...) { return Envelope(); } }
virtual void sendRaw(bytes const& _payload, Topic _topic, unsigned _ttl) { inject(Message(time(0) + _ttl, _ttl, _topic, _payload)); }
private: private:
void streamMessage(h256 _m, RLPStream& _s) const; void streamMessage(h256 _m, RLPStream& _s) const;
@ -66,7 +65,7 @@ private:
void noteChanged(h256 _messageHash, h256 _filter); void noteChanged(h256 _messageHash, h256 _filter);
mutable dev::SharedMutex x_messages; mutable dev::SharedMutex x_messages;
std::map<h256, Message> m_messages; std::map<h256, Envelope> m_messages;
mutable dev::Mutex m_filterLock; mutable dev::Mutex m_filterLock;
std::map<h256, InstalledFilter> m_filters; std::map<h256, InstalledFilter> m_filters;

13
libwhisper/WhisperPeer.cpp
View File

@ -71,7 +71,7 @@ bool WhisperPeer::interpret(unsigned _id, RLP const& _r)
unsigned n = 0; unsigned n = 0;
for (auto i: _r) for (auto i: _r)
if (n++) if (n++)
host()->inject(Message(i), this); host()->inject(Envelope(i), this);
sendMessages(); sendMessages();
break; break;
} }
@ -86,6 +86,7 @@ void WhisperPeer::sendMessages()
RLPStream amalg; RLPStream amalg;
unsigned n = 0; unsigned n = 0;
{
Guard l(x_unseen); Guard l(x_unseen);
while (m_unseen.size()) while (m_unseen.size())
{ {
@ -94,16 +95,18 @@ void WhisperPeer::sendMessages()
host()->streamMessage(p.second, amalg); host()->streamMessage(p.second, amalg);
n++; n++;
} }
}
if (!n)
// pause for a bit if no messages to send - this is horrible and broken.
// the message subsystem should really just keep pumping out messages while m_unseen.size() and there's bandwidth for them.
this_thread::sleep_for(chrono::milliseconds(20));
if (n)
{ {
RLPStream s; RLPStream s;
prep(s, MessagesPacket, n).appendRaw(amalg.out(), n); prep(s, MessagesPacket, n).appendRaw(amalg.out(), n);
sealAndSend(s); sealAndSend(s);
} }
else
// just pause if no messages to send
this_thread::sleep_for(chrono::milliseconds(100));
} }
void WhisperPeer::noteNewMessage(h256 _h, Message const& _m) void WhisperPeer::noteNewMessage(h256 _h, Message const& _m)

2
libwhisper/WhisperPeer.h
View File

@ -59,7 +59,7 @@ public:
WhisperHost* host() const; WhisperHost* host() const;
private: private:
virtual bool interpret(unsigned _id, RLP const&); virtual bool interpret(unsigned _id, RLP const&) override;
void sendMessages(); void sendMessages();

14
stdserv.js
View File

@ -1,3 +1,5 @@
eth = web3.eth;
env.note('Creating Config...') env.note('Creating Config...')
var configCode = eth.lll(" var configCode = eth.lll("
{ {
@ -277,25 +279,25 @@ eth.transact({ 'to': config, 'data': ['3', exchange] });
env.note('Register my name...') env.note('Register my name...')
eth.transact({ 'to': nameReg, 'data': [ eth.fromAscii('register'), eth.fromAscii('Gav') ] }); eth.transact({ 'to': nameReg, 'data': [ web3.fromAscii('register'), web3.fromAscii('Gav') ] });
env.note('Dole out ETH to other address...') env.note('Dole out ETH to other address...')
eth.transact({ 'value': '100000000000000000000', 'to': eth.accounts[1] }); eth.transact({ 'value': '100000000000000000000', 'to': eth.accounts[1] });
env.note('Register my other name...') env.note('Register my other name...')
eth.transact({ 'from': eth.keys[1], 'to': nameReg, 'data': [ eth.fromAscii('register'), eth.fromAscii("Gav Would") ] }); eth.transact({ 'from': eth.keys[1], 'to': nameReg, 'data': [ web3.fromAscii('register'), web3.fromAscii("Gav Would") ] });
env.note('Approve Exchange...') env.note('Approve Exchange...')
eth.transact({ 'to': gavCoin, 'data': [ eth.fromAscii('approve'), exchange ] }); eth.transact({ 'to': gavCoin, 'data': [ web3.fromAscii('approve'), exchange ] });
env.note('Approve Exchange on other address...') env.note('Approve Exchange on other address...')
eth.transact({ 'from': eth.keys[1], 'to': gavCoin, 'data': [ eth.fromAscii('approve'), exchange ] }); eth.transact({ 'from': eth.keys[1], 'to': gavCoin, 'data': [ web3.fromAscii('approve'), exchange ] });
env.note('Make offer 5000GAV/5ETH...') env.note('Make offer 5000GAV/5ETH...')
eth.transact({ 'to': exchange, 'data': [eth.fromAscii('new'), gavCoin, '5000', '0', '5000000000000000000'] }); eth.transact({ 'to': exchange, 'data': [web3.fromAscii('new'), gavCoin, '5000', '0', '5000000000000000000'] });
env.note('Register gav.eth...') env.note('Register gav.eth...')
eth.transact({ 'to': dnsReg, 'data': [eth.fromAscii('register'), eth.fromAscii('gav'), eth.fromAscii('opensecrecy.com')] }); eth.transact({ 'to': dnsReg, 'data': [web3.fromAscii('register'), web3.fromAscii('gav'), web3.fromAscii('opensecrecy.com')] });
env.note('All done.') env.note('All done.')

Write Preview
Loading…
Cancel
Save