|
|
|
@ -27,7 +27,6 @@ |
|
|
|
#include <libdevcore/CommonIO.h> |
|
|
|
#include <libdevcore/StructuredLogger.h> |
|
|
|
#include <libethcore/Exceptions.h> |
|
|
|
#include "RLPxHandshake.h" |
|
|
|
#include "Host.h" |
|
|
|
#include "Capability.h" |
|
|
|
using namespace std; |
|
|
|
@ -156,13 +155,37 @@ void Session::serviceNodesRequest() |
|
|
|
addNote("peers", "done"); |
|
|
|
} |
|
|
|
|
|
|
|
bool Session::interpret(PacketType _t, RLP const& _r) |
|
|
|
bool Session::readPacket(uint16_t _capId, PacketType _t, RLP const& _r) |
|
|
|
{ |
|
|
|
m_lastReceived = chrono::steady_clock::now(); |
|
|
|
|
|
|
|
clog(NetRight) << _t << _r; |
|
|
|
try // Generic try-catch block designed to capture RLP format errors - TODO: give decent diagnostics, make a bit more specific over what is caught.
|
|
|
|
{ |
|
|
|
// v4 frame headers are useless, offset packet type used
|
|
|
|
// v5 protocol type is in header, packet type not offset
|
|
|
|
if (_capId == 0 && _t < UserPacket) |
|
|
|
return interpret(_t, _r); |
|
|
|
if (m_info.protocolVersion >= 5) |
|
|
|
for (auto const& i: m_capabilities) |
|
|
|
if (_capId == (uint16_t)i.first.second) |
|
|
|
return i.second->m_enabled ? i.second->interpret(_t, _r) : true; |
|
|
|
if (m_info.protocolVersion <= 4) |
|
|
|
for (auto const& i: m_capabilities) |
|
|
|
if (_t >= (int)i.second->m_idOffset && _t - i.second->m_idOffset < i.second->hostCapability()->messageCount()) |
|
|
|
return i.second->m_enabled ? i.second->interpret(_t - i.second->m_idOffset, _r) : true; |
|
|
|
return false; |
|
|
|
} |
|
|
|
catch (std::exception const& _e) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Peer causing an exception:" << _e.what() << _r; |
|
|
|
disconnect(BadProtocol); |
|
|
|
return true; |
|
|
|
} |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
bool Session::interpret(PacketType _t, RLP const& _r) |
|
|
|
{ |
|
|
|
switch (_t) |
|
|
|
{ |
|
|
|
case DisconnectPacket: |
|
|
|
@ -251,23 +274,8 @@ bool Session::interpret(PacketType _t, RLP const& _r) |
|
|
|
} |
|
|
|
break; |
|
|
|
default: |
|
|
|
for (auto const& i: m_capabilities) |
|
|
|
if (_t >= (int)i.second->m_idOffset && _t - i.second->m_idOffset < i.second->hostCapability()->messageCount()) |
|
|
|
{ |
|
|
|
if (i.second->m_enabled) |
|
|
|
return i.second->interpret(_t - i.second->m_idOffset, _r); |
|
|
|
else |
|
|
|
return true; |
|
|
|
} |
|
|
|
return false; |
|
|
|
} |
|
|
|
} |
|
|
|
catch (std::exception const& _e) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Peer causing an exception:" << _e.what() << _r; |
|
|
|
disconnect(BadProtocol); |
|
|
|
return true; |
|
|
|
} |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
@ -292,12 +300,9 @@ void Session::sealAndSend(RLPStream& _s) |
|
|
|
|
|
|
|
bool Session::checkPacket(bytesConstRef _msg) |
|
|
|
{ |
|
|
|
if (_msg.size() < 2) |
|
|
|
if (_msg[0] > 0x7f || _msg.size() < 2) |
|
|
|
return false; |
|
|
|
if (_msg[0] > 0x7f) |
|
|
|
return false; |
|
|
|
RLP r(_msg.cropped(1)); |
|
|
|
if (r.actualSize() + 1 != _msg.size()) |
|
|
|
if (RLP(_msg.cropped(1)).actualSize() + 1 != _msg.size()) |
|
|
|
return false; |
|
|
|
return true; |
|
|
|
} |
|
|
|
@ -413,65 +418,43 @@ void Session::doRead() |
|
|
|
{ |
|
|
|
ThreadContext tc(info().id.abridged()); |
|
|
|
ThreadContext tc2(info().clientVersion); |
|
|
|
if (ec && ec.category() != boost::asio::error::get_misc_category() && ec.value() != boost::asio::error::eof) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Error reading: " << ec.message(); |
|
|
|
drop(TCPError); |
|
|
|
} |
|
|
|
else if (ec && length == 0) |
|
|
|
if (!checkRead(h256::size, ec, length)) |
|
|
|
return; |
|
|
|
else |
|
|
|
{ |
|
|
|
/// authenticate and decrypt header
|
|
|
|
bytesRef header(m_data.data(), h256::size); |
|
|
|
if (!m_io->authAndDecryptHeader(header)) |
|
|
|
else if (!m_io->authAndDecryptHeader(bytesRef(m_data.data(), length))) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "header decrypt failed"; |
|
|
|
drop(BadProtocol); // todo: better error
|
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
/// check frame size
|
|
|
|
uint32_t frameSize = (m_data[0] * 256 + m_data[1]) * 256 + m_data[2]; |
|
|
|
if (frameSize >= (uint32_t)1 << 24) |
|
|
|
RLPXFrameInfo header; |
|
|
|
try |
|
|
|
{ |
|
|
|
clog(NetWarn) << "frame size too large"; |
|
|
|
header = RLPXFrameInfo(bytesConstRef(m_data.data(), length)); |
|
|
|
} |
|
|
|
catch (std::exception const& _e) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Exception decoding frame header RLP:" << bytesConstRef(m_data.data(), h128::size).cropped(3); |
|
|
|
drop(BadProtocol); |
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
/// rlp of header has protocol-type, sequence-id[, total-packet-size]
|
|
|
|
bytes headerRLP(13); |
|
|
|
bytesConstRef(m_data.data(), h128::size).cropped(3).copyTo(&headerRLP); |
|
|
|
|
|
|
|
/// read padded frame and mac
|
|
|
|
auto tlen = frameSize + ((16 - (frameSize % 16)) % 16) + h128::size; |
|
|
|
ba::async_read(m_socket->ref(), boost::asio::buffer(m_data, tlen), [this, self, headerRLP, frameSize, tlen](boost::system::error_code ec, std::size_t length) |
|
|
|
auto tlen = header.length + header.padding + h128::size; |
|
|
|
ba::async_read(m_socket->ref(), boost::asio::buffer(m_data, tlen), [this, self, header, tlen](boost::system::error_code ec, std::size_t length) |
|
|
|
{ |
|
|
|
ThreadContext tc(info().id.abridged()); |
|
|
|
ThreadContext tc2(info().clientVersion); |
|
|
|
if (ec && ec.category() != boost::asio::error::get_misc_category() && ec.value() != boost::asio::error::eof) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Error reading: " << ec.message(); |
|
|
|
drop(TCPError); |
|
|
|
} |
|
|
|
else if (ec && length < tlen) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Error reading - Abrupt peer disconnect: " << ec.message(); |
|
|
|
repMan().noteRude(*this); |
|
|
|
drop(TCPError); |
|
|
|
if (!checkRead(tlen, ec, length)) |
|
|
|
return; |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
if (!m_io->authAndDecryptFrame(bytesRef(m_data.data(), tlen))) |
|
|
|
else if (!m_io->authAndDecryptFrame(bytesRef(m_data.data(), tlen))) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "frame decrypt failed"; |
|
|
|
drop(BadProtocol); // todo: better error
|
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
bytesConstRef frame(m_data.data(), frameSize); |
|
|
|
bytesConstRef frame(m_data.data(), header.length); |
|
|
|
if (!checkPacket(frame)) |
|
|
|
{ |
|
|
|
cerr << "Received " << frame.size() << ": " << toHex(frame) << endl; |
|
|
|
@ -483,12 +466,30 @@ void Session::doRead() |
|
|
|
{ |
|
|
|
auto packetType = (PacketType)RLP(frame.cropped(0, 1)).toInt<unsigned>(); |
|
|
|
RLP r(frame.cropped(1)); |
|
|
|
if (!interpret(packetType, r)) |
|
|
|
if (!readPacket(header.protocolId, packetType, r)) |
|
|
|
clog(NetWarn) << "Couldn't interpret packet." << RLP(r); |
|
|
|
} |
|
|
|
doRead(); |
|
|
|
} |
|
|
|
}); |
|
|
|
} |
|
|
|
}); |
|
|
|
} |
|
|
|
|
|
|
|
bool Session::checkRead(std::size_t _expected, boost::system::error_code _ec, std::size_t _length) |
|
|
|
{ |
|
|
|
if (_ec && _ec.category() != boost::asio::error::get_misc_category() && _ec.value() != boost::asio::error::eof) |
|
|
|
{ |
|
|
|
clog(NetConnect) << "Error reading: " << _ec.message(); |
|
|
|
drop(TCPError); |
|
|
|
return false; |
|
|
|
} |
|
|
|
else if (_ec && _length < _expected) |
|
|
|
{ |
|
|
|
clog(NetWarn) << "Error reading - Abrupt peer disconnect: " << _ec.message(); |
|
|
|
repMan().noteRude(*this); |
|
|
|
drop(TCPError); |
|
|
|
return false; |
|
|
|
} |
|
|
|
// If this fails then there's an unhandled asio error
|
|
|
|
assert(_expected == _length); |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
subtly
10 years ago