be16f80abc
Any projects which want to use Hush code from now on will need to be licensed as GPLv3 or we will send the lawyers: https://www.softwarefreedom.org/ Notably, Komodo (KMD) is licensed as GPLv2 and is no longer compatible to receive code changes, without causing legal issues. MIT projects, such as Zcash, also cannot pull in changes from the Hush Full Node without permission from The Hush Developers, which may in some circumstances grant an MIT license on a case-by-case basis.
284 lines
8.4 KiB
C++
284 lines
8.4 KiB
C++
// Copyright (c) 2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Copyright (c) 2019-2020 The Hush developers
|
|
// Distributed under the GPLv3 software license, see the accompanying
|
|
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|
|
|
/******************************************************************************
|
|
* Copyright © 2014-2019 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#include "alert.h"
|
|
|
|
#include "clientversion.h"
|
|
#include "net.h"
|
|
#include "pubkey.h"
|
|
#include "timedata.h"
|
|
#include "ui_interface.h"
|
|
#include "util.h"
|
|
|
|
#include <stdint.h>
|
|
#include <algorithm>
|
|
#include <map>
|
|
|
|
#include <boost/algorithm/string/classification.hpp>
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
#include <boost/foreach.hpp>
|
|
#include <boost/thread.hpp>
|
|
|
|
using namespace std;
|
|
|
|
map<uint256, CAlert> mapAlerts;
|
|
CCriticalSection cs_mapAlerts;
|
|
|
|
void CUnsignedAlert::SetNull()
|
|
{
|
|
nVersion = 1;
|
|
nRelayUntil = 0;
|
|
nExpiration = 0;
|
|
nID = 0;
|
|
nCancel = 0;
|
|
setCancel.clear();
|
|
nMinVer = 0;
|
|
nMaxVer = 0;
|
|
setSubVer.clear();
|
|
nPriority = 0;
|
|
|
|
strComment.clear();
|
|
strStatusBar.clear();
|
|
strRPCError.clear();
|
|
}
|
|
|
|
std::string CUnsignedAlert::ToString() const
|
|
{
|
|
std::string strSetCancel;
|
|
BOOST_FOREACH(int n, setCancel)
|
|
strSetCancel += strprintf("%d ", n);
|
|
std::string strSetSubVer;
|
|
BOOST_FOREACH(const std::string& str, setSubVer)
|
|
strSetSubVer += "\"" + str + "\" ";
|
|
return strprintf(
|
|
"CAlert(\n"
|
|
" nVersion = %d\n"
|
|
" nRelayUntil = %d\n"
|
|
" nExpiration = %d\n"
|
|
" nID = %d\n"
|
|
" nCancel = %d\n"
|
|
" setCancel = %s\n"
|
|
" nMinVer = %d\n"
|
|
" nMaxVer = %d\n"
|
|
" setSubVer = %s\n"
|
|
" nPriority = %d\n"
|
|
" strComment = \"%s\"\n"
|
|
" strStatusBar = \"%s\"\n"
|
|
" strRPCError = \"%s\"\n"
|
|
")\n",
|
|
nVersion,
|
|
nRelayUntil,
|
|
nExpiration,
|
|
nID,
|
|
nCancel,
|
|
strSetCancel,
|
|
nMinVer,
|
|
nMaxVer,
|
|
strSetSubVer,
|
|
nPriority,
|
|
strComment,
|
|
strStatusBar,
|
|
strRPCError);
|
|
}
|
|
|
|
void CAlert::SetNull()
|
|
{
|
|
CUnsignedAlert::SetNull();
|
|
vchMsg.clear();
|
|
vchSig.clear();
|
|
}
|
|
|
|
bool CAlert::IsNull() const
|
|
{
|
|
return (nExpiration == 0);
|
|
}
|
|
|
|
uint256 CAlert::GetHash() const
|
|
{
|
|
return Hash(this->vchMsg.begin(), this->vchMsg.end());
|
|
}
|
|
|
|
bool CAlert::IsInEffect() const
|
|
{
|
|
return (GetTime() < nExpiration);
|
|
}
|
|
|
|
bool CAlert::Cancels(const CAlert& alert) const
|
|
{
|
|
if (!IsInEffect())
|
|
return false; // this was a no-op before 31403
|
|
return (alert.nID <= nCancel || setCancel.count(alert.nID));
|
|
}
|
|
|
|
bool CAlert::AppliesTo(int nVersion, const std::string& strSubVerIn) const
|
|
{
|
|
// TODO: rework for client-version-embedded-in-strSubVer ?
|
|
return (IsInEffect() &&
|
|
nMinVer <= nVersion && nVersion <= nMaxVer &&
|
|
(setSubVer.empty() || setSubVer.count(strSubVerIn)));
|
|
}
|
|
|
|
bool CAlert::AppliesToMe() const
|
|
{
|
|
return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(GetArg("-clientname","MagicBean"), CLIENT_VERSION, std::vector<std::string>()));
|
|
}
|
|
|
|
bool CAlert::RelayTo(CNode* pnode) const
|
|
{
|
|
if (!IsInEffect())
|
|
return false;
|
|
// don't relay to nodes which haven't sent their version message
|
|
if (pnode->nVersion == 0)
|
|
return false;
|
|
// returns true if wasn't already contained in the set
|
|
if (pnode->setKnown.insert(GetHash()).second)
|
|
{
|
|
if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
|
|
AppliesToMe() ||
|
|
GetTime() < nRelayUntil)
|
|
{
|
|
pnode->PushMessage("alert", *this);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CAlert::CheckSignature(const std::vector<unsigned char>& alertKey) const
|
|
{
|
|
CPubKey key(alertKey);
|
|
if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
|
|
return error("CAlert::CheckSignature(): verify signature failed");
|
|
|
|
// Now unserialize the data
|
|
CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION);
|
|
sMsg >> *(CUnsignedAlert*)this;
|
|
return true;
|
|
}
|
|
|
|
CAlert CAlert::getAlertByHash(const uint256 &hash)
|
|
{
|
|
CAlert retval;
|
|
{
|
|
LOCK(cs_mapAlerts);
|
|
map<uint256, CAlert>::iterator mi = mapAlerts.find(hash);
|
|
if(mi != mapAlerts.end())
|
|
retval = mi->second;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
bool CAlert::ProcessAlert(const std::vector<unsigned char>& alertKey, bool fThread)
|
|
{
|
|
if (!CheckSignature(alertKey))
|
|
return false;
|
|
if (!IsInEffect())
|
|
return false;
|
|
|
|
// alert.nID=max is reserved for if the alert key is
|
|
// compromised. It must have a pre-defined message,
|
|
// must never expire, must apply to all versions,
|
|
// and must cancel all previous
|
|
// alerts or it will be ignored (so an attacker can't
|
|
// send an "everything is OK, don't panic" version that
|
|
// cannot be overridden):
|
|
int maxInt = std::numeric_limits<int>::max();
|
|
if (nID == maxInt)
|
|
{
|
|
if (!(
|
|
nExpiration == maxInt &&
|
|
nCancel == (maxInt-1) &&
|
|
nMinVer == 0 &&
|
|
nMaxVer == maxInt &&
|
|
setSubVer.empty() &&
|
|
nPriority == maxInt &&
|
|
strStatusBar == "URGENT: Alert key compromised, upgrade required"
|
|
))
|
|
return false;
|
|
}
|
|
|
|
{
|
|
LOCK(cs_mapAlerts);
|
|
// Cancel previous alerts
|
|
for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
|
|
{
|
|
const CAlert& alert = (*mi).second;
|
|
if (Cancels(alert))
|
|
{
|
|
LogPrint("alert", "cancelling alert %d\n", alert.nID);
|
|
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
|
|
mapAlerts.erase(mi++);
|
|
}
|
|
else if (!alert.IsInEffect())
|
|
{
|
|
LogPrint("alert", "expiring alert %d\n", alert.nID);
|
|
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
|
|
mapAlerts.erase(mi++);
|
|
}
|
|
else
|
|
mi++;
|
|
}
|
|
|
|
// Check if this alert has been cancelled
|
|
BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
|
|
{
|
|
const CAlert& alert = item.second;
|
|
if (alert.Cancels(*this))
|
|
{
|
|
LogPrint("alert", "alert already cancelled by %d\n", alert.nID);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Add to mapAlerts
|
|
mapAlerts.insert(make_pair(GetHash(), *this));
|
|
// Notify UI and -alertnotify if it applies to me
|
|
if(AppliesToMe())
|
|
{
|
|
uiInterface.NotifyAlertChanged(GetHash(), CT_NEW);
|
|
Notify(strStatusBar, fThread);
|
|
}
|
|
}
|
|
|
|
LogPrint("alert", "accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CAlert::Notify(const std::string& strMessage, bool fThread)
|
|
{
|
|
std::string strCmd = GetArg("-alertnotify", "");
|
|
if (strCmd.empty()) return;
|
|
|
|
// Alert text should be plain ascii coming from a trusted source, but to
|
|
// be safe we first strip anything not in safeChars, then add single quotes around
|
|
// the whole string before passing it to the shell:
|
|
std::string singleQuote("'");
|
|
std::string safeStatus = SanitizeString(strMessage);
|
|
safeStatus = singleQuote+safeStatus+singleQuote;
|
|
boost::replace_all(strCmd, "%s", safeStatus);
|
|
|
|
if (fThread)
|
|
boost::thread t(runCommand, strCmd); // thread runs free
|
|
else
|
|
runCommand(strCmd);
|
|
}
|