QObject* FileTransferManager::SendFile (const QString& id,
const QString&, const QString& name, const QString&)
{
const auto toxThread = ToxThread_.lock ();
if (!toxThread)
{
qWarning () << Q_FUNC_INFO
<< "Tox thread is not available";
return nullptr;
}
const auto contact = Acc_->GetByAzothId (id);
if (!contact)
{
qWarning () << Q_FUNC_INFO
<< "unable to find contact by the ID"
<< id;
return nullptr;
}
const auto transfer = new FileTransferOut { id, contact->GetPubKey (), name, toxThread };
connect (this,
SIGNAL (gotFileControl (qint32, qint8, qint8, QByteArray)),
transfer,
SLOT (handleFileControl (qint32, qint8, qint8, QByteArray)));
return transfer;
}
bool CECKey::SignCompact(const uint256 &hash, unsigned char *p64, int &rec) {
bool fOk = false;
ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
if (sig==NULL)
return false;
memset(p64, 0, 64);
int nBitsR = BN_num_bits(sig->r);
int nBitsS = BN_num_bits(sig->s);
if (nBitsR <= 256 && nBitsS <= 256) {
std::vector<unsigned char> pubkey;
GetPubKey(pubkey, true);
for (int i=0; i<4; i++) {
CECKey keyRec;
if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1) {
std::vector<unsigned char> pubkeyRec;
keyRec.GetPubKey(pubkeyRec, true);
if (pubkeyRec == pubkey) {
rec = i;
fOk = true;
break;
}
}
}
assert(fOk);
BN_bn2bin(sig->r,&p64[32-(nBitsR+7)/8]);
BN_bn2bin(sig->s,&p64[64-(nBitsS+7)/8]);
}
ECDSA_SIG_free(sig);
return fOk;
}
bool CKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
{
CKey key;
if (!key.SetCompactSignature(hash, vchSig))
return false;
if (GetPubKey() != key.GetPubKey())
return false;
return true;
}
bool CBasicKeyStore::HaveCScript(const uint160& hash) const
{
bool result;
CBitcoinAddress address;
std::vector<unsigned char> vchPubKey;
address.SetScriptHash160(hash);
CRITICAL_BLOCK(cs_KeyStore)
result = (mapScripts.count(hash) > 0) || GetPubKey(address, vchPubKey);
return result;
}
bool CKey::IsValid()
{
if (!fSet)
return false;
bool fCompr;
CSecret secret = GetSecret(fCompr);
CKey key2;
key2.SetSecret(secret, fCompr);
return GetPubKey() == key2.GetPubKey();
}
bool CAccount::EncryptKeys(const CKeyingMaterial& vMasterKeyIn)
{
if (!externalKeyStore.EncryptKeys(vMasterKeyIn))
return false;
if (!internalKeyStore.EncryptKeys(vMasterKeyIn))
return false;
if (pactiveWallet)
{
{
std::set<CKeyID> setAddress;
GetKeys(setAddress);
LOCK(pactiveWallet->cs_wallet);
for (const auto& keyID : setAddress)
{
CPubKey pubKey;
if (!GetPubKey(keyID, pubKey))
{
LogPrintf("CAccount::EncryptKeys(): Failed to get pubkey\n");
return false;
}
if (pactiveWallet->pwalletdbEncryption)
pactiveWallet->pwalletdbEncryption->EraseKey(pubKey);
else
CWalletDB(*pactiveWallet->dbw).EraseKey(pubKey);
std::vector<unsigned char> secret;
if (!GetKey(keyID, secret))
{
LogPrintf("CAccount::EncryptKeys(): Failed to get crypted key\n");
return false;
}
if (pactiveWallet->pwalletdbEncryption)
{
if (!pactiveWallet->pwalletdbEncryption->WriteCryptedKey(pubKey, secret, pactiveWallet->mapKeyMetadata[keyID], getUUIDAsString(getUUID()), KEYCHAIN_EXTERNAL))
{
LogPrintf("CAccount::EncryptKeys(): Failed to write key\n");
return false;
}
}
else
{
if (!CWalletDB(*pactiveWallet->dbw).WriteCryptedKey(pubKey, secret, pactiveWallet->mapKeyMetadata[keyID], getUUIDAsString(getUUID()), KEYCHAIN_EXTERNAL))
{
LogPrintf("CAccount::EncryptKeys(): Failed to write key\n");
return false;
}
}
}
}
}
return true;
}
CPubKey CAccountHD::GenerateNewKey(CWallet& wallet, int keyChain)
{
CExtPubKey childKey;
do {
GetPubKey(childKey, keyChain);
} while (wallet.HaveKey(childKey.pubkey.GetID())); ///
LogPrintf("CAccount::GenerateNewKey(): NewHDKey [%s]\n", CBitcoinAddress(childKey.pubkey.GetID()).ToString());
if (!wallet.AddKeyPubKey(childKey.nChild, childKey.pubkey, *this, keyChain))
throw std::runtime_error("CAccount::GenerateNewKey(): AddKeyPubKey failed");
return childKey.pubkey;
}
//rsa密钥对产生
bool CRsaDesManager::GenRsaKeypairs(void)
{
RSA *rsa = NULL;
FILE *fKeyFile = NULL;
fKeyFile = fopen("raskeys.key", "wb");
if(fKeyFile == NULL)
{
return false;
}
int i = 0;
//把密钥对写入文件，以后从文件里读取
unsigned char ucPubKey[RSA_KEY_LEN] = {0}, ucPriKey[RSA_KEY_LEN] = {0};
for(i = 0; i < RSA_KEY_PAIR_NUM; ++i)
{
//生成RSA密钥对：
rsa = RSA_new();
rsa = RSA_generate_key(RSA_KEY_LEN, RSA_F4, NULL, NULL);
unsigned char* pt = ucPubKey;
ui32 len = i2d_RSAPublicKey(rsa, &pt);
if(!GetPubKey(ucPubKey, len, &m_pPubRSA[i]))
break;
fwrite((unsigned char*)&len, 1, sizeof(ui32), fKeyFile);
fwrite(ucPubKey, 1, len, fKeyFile);
m_strPubKeys[i].clear();
m_strPubKeys[i].append((char*)ucPubKey, len);
unsigned char* pt2 = ucPriKey;
len = i2d_RSAPrivateKey(rsa,&pt2);
if(!GetPriKey(ucPriKey, len, &m_pPriRSA[i]))
break;
fwrite((unsigned char*)&len, 1, sizeof(ui32), fKeyFile);
fwrite(ucPriKey, 1, len, fKeyFile);
if(rsa != NULL)
{
RSA_free(rsa);
rsa = NULL;
}
}
fclose(fKeyFile);
if(i < RSA_KEY_PAIR_NUM)
return false;
return true;
}
//rsa密钥对载入
bool CRsaDesManager::LoadRsaKeypairs(void)
{
FILE *fKeyFile = NULL;
fKeyFile = fopen("raskeys.key", "rb");
if(fKeyFile == NULL)
{
return false;
}
fseek(fKeyFile, 0, SEEK_SET);
char szLen[sizeof(ui32)];
char szKey[RSA_KEY_LEN];
int iLen = 0;
size_t iReadLen = 0;
int i = 0;
for(i = 0; i < RSA_KEY_PAIR_NUM ; ++i)
{
iReadLen = fread(szLen, 1, sizeof(ui32), fKeyFile);
if(iReadLen != sizeof(ui32))
break;
iLen = *(ui32*)szLen;
iReadLen = fread(szKey, 1, iLen, fKeyFile);
if(iReadLen != iLen)
break;
if(!GetPubKey((unsigned char*)szKey, iLen, &m_pPubRSA[i]))
break;
m_strPubKeys[i].clear();
m_strPubKeys[i].append(szKey, iLen);
iReadLen = fread(szLen, 1, sizeof(ui32), fKeyFile);
if(iReadLen != sizeof(ui32))
break;
iLen = *(ui32*)szLen;
iReadLen = fread(szKey, 1, iLen, fKeyFile);
if(iReadLen != iLen)
break;
if(!GetPriKey((unsigned char*)szKey, iLen, &m_pPriRSA[i]))
break;
}
fclose(fKeyFile);
if(i < RSA_KEY_PAIR_NUM)
return false;
return true;
}
CPubKey CAccountHD::GenerateNewKey(CWallet& wallet, CKeyMetadata& metadata, int keyChain)
{
CExtPubKey childKey;
do
{
GetPubKey(childKey, keyChain);
}
while( wallet.HaveKey(childKey.pubkey.GetID()) );//fixme: (Post-2.1) (BIP44) No longer need wallet here.
//LogPrintf("CAccount::GenerateNewKey(): NewHDKey [%s]\n", CGuldenAddress(childKey.pubkey.GetID()).ToString());
metadata.hdKeypath = std::string("m/44'/87'/") + std::to_string(m_nIndex) + "/" + std::to_string(keyChain) + "/" + std::to_string(childKey.nChild) + "'";
metadata.hdAccountUUID = getUUIDAsString(getUUID());
if (!wallet.AddHDKeyPubKey(childKey.nChild, childKey.pubkey, *this, keyChain))
throw std::runtime_error("CAccount::GenerateNewKey(): AddKeyPubKey failed");
return childKey.pubkey;
}
bool CRsaDesManager::RSAPubEncode(const string& strRsaPubKey, const string& strInData, string& strOutData)
{
RSA * pRsa;
if(!GetPubKey((unsigned char*)strRsaPubKey.c_str(), strRsaPubKey.size(), &pRsa))
return false;
unsigned char pcOutData[1024];
unsigned char *pcInData = (unsigned char *)strInData.c_str();
unsigned long ulOutLen = 0, ulInLen = strInData.size();
unsigned long ulInTmpLen = std::min<int>(ulInLen, RSA_ENCODE_LEN_UNIT);
unsigned long ulOutTmpLen = 0;
while(ulInLen)
{
ulOutTmpLen = RSA_public_encrypt(ulInTmpLen, pcInData, pcOutData+ulOutLen, pRsa, 1);
if(ulOutTmpLen <= 0)
break;
ulOutLen = ulOutLen + ulOutTmpLen;
pcInData = pcInData+ulInTmpLen;
ulInLen -= ulInTmpLen;
ulInTmpLen = std::min<int>(ulInLen, RSA_ENCODE_LEN_UNIT);
}
RSA_free(pRsa);
strOutData.clear();
if(ulInLen <= 0)
{
strOutData.append((char*)pcOutData, ulOutTmpLen);
return true;
}
else
{
return false;
}
}
/**
* Sign scriptPubKey using signature made with creator.
* Signatures are returned in scriptSigRet (or returns false if scriptPubKey can't be signed),
* unless whichTypeRet is TX_SCRIPTHASH, in which case scriptSigRet is the redemption script.
* Returns false if scriptPubKey could not be completely satisfied.
*/
static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& scriptPubKey,
std::vector<valtype>& ret, txnouttype& whichTypeRet, SigVersion sigversion, SignatureData& sigdata)
{
CScript scriptRet;
uint160 h160;
ret.clear();
std::vector<unsigned char> sig;
std::vector<valtype> vSolutions;
if (!Solver(scriptPubKey, whichTypeRet, vSolutions))
return false;
switch (whichTypeRet)
{
case TX_NONSTANDARD:
case TX_NULL_DATA:
case TX_WITNESS_UNKNOWN:
return false;
case TX_PUBKEY:
if (!CreateSig(creator, sigdata, provider, sig, CPubKey(vSolutions[0]), scriptPubKey, sigversion)) return false;
ret.push_back(std::move(sig));
return true;
case TX_PUBKEYHASH: {
CKeyID keyID = CKeyID(uint160(vSolutions[0]));
CPubKey pubkey;
GetPubKey(provider, sigdata, keyID, pubkey);
if (!CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) return false;
ret.push_back(std::move(sig));
ret.push_back(ToByteVector(pubkey));
return true;
}
case TX_SCRIPTHASH:
if (GetCScript(provider, sigdata, uint160(vSolutions[0]), scriptRet)) {
ret.push_back(std::vector<unsigned char>(scriptRet.begin(), scriptRet.end()));
return true;
}
return false;
case TX_MULTISIG: {
size_t required = vSolutions.front()[0];
ret.push_back(valtype()); // workaround CHECKMULTISIG bug
for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
CPubKey pubkey = CPubKey(vSolutions[i]);
if (ret.size() < required + 1 && CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) {
ret.push_back(std::move(sig));
}
}
bool ok = ret.size() == required + 1;
for (size_t i = 0; i + ret.size() < required + 1; ++i) {
ret.push_back(valtype());
}
return ok;
}
case TX_WITNESS_V0_KEYHASH:
ret.push_back(vSolutions[0]);
return true;
case TX_WITNESS_V0_SCRIPTHASH:
CRIPEMD160().Write(&vSolutions[0][0], vSolutions[0].size()).Finalize(h160.begin());
if (GetCScript(provider, sigdata, h160, scriptRet)) {
ret.push_back(std::vector<unsigned char>(scriptRet.begin(), scriptRet.end()));
return true;
}
return false;
default:
return false;
}
}
void SampleEscrowServerZmq::UpdateServer()
{
//while (!Modules::shutDown)
{
zmq_msg_t request; // = new zmq_msg_t();
zmq_msg_init(&request);
// Wait for next request from client
zmq_pollitem_t item;
item.socket = this->serverSocket;
item.fd = 0;
item.events = ZMQ_POLLIN;
item.revents = 0;
/*zmq_pollitem_t items[] = { item }; //{ this->serverSocket, 0, ZMQ_POLLIN, 0 } };
zmq_poll(&items[0], 1, 1000);
// Return if no request
if (!(items[0].revents & ZMQ_POLLIN))
{
zmq_msg_close(&request);
return;
}*/
#ifdef OT_USE_ZMQ4
if(zmq_msg_recv(&request, this->serverSocket, ZMQ_DONTWAIT) == -1)
#else
#ifndef Q_OS_MAC
if(zmq_recv(this->serverSocket, &request, ZMQ_NOBLOCK) == -1)
#endif
#endif
{
zmq_msg_close(&request);
return;
}
if(zmq_msg_size(&request) < NetMessageSizes[Unknown])
{
zmq_msg_close(&request);
return;
}
NetMessageType messageType = static_cast<NetMessageType>(static_cast<BtcNetMsg*>(zmq_msg_data(&request))->MessageType);
if(zmq_msg_size(&request) != NetMessageSizes[messageType])
{
zmq_msg_close(&request);
return;
}
BtcNetMsg* replyPtr = new BtcNetMsg();
switch(messageType)
{
case Unknown:
{
break;
}
case Connect:
{
BtcNetMsgConnectPtr message = BtcNetMsgConnectPtr(new BtcNetMsgConnect());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
ClientConnected(message);
std::printf("client connected\n");
std::cout.flush();
break;
}
case ReqDeposit:
{
BtcNetMsgReqDepositPtr message = BtcNetMsgReqDepositPtr(new BtcNetMsgReqDeposit());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
bool accepted = RequestEscrowDeposit(message);
BtcNetMsgDepositReply* replyMsg = new BtcNetMsgDepositReply();
replyMsg->accepted = static_cast<int8_t>(accepted);
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case GetMultiSigAddr:
{
BtcNetMsgGetDepositAddrPtr message = BtcNetMsgGetDepositAddrPtr(new BtcNetMsgGetDepositAddr());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
std::string multiSigAddr = RequestDepositAddress(message);
if(multiSigAddr.empty())
break;
BtcNetMsgDepositAddr* replyMsg = new BtcNetMsgDepositAddr();
memcpy(replyMsg->address, multiSigAddr.c_str(), std::min(multiSigAddr.size(), sizeof(replyMsg->address)));
std::printf("server %s sending multisig addr %s\n", this->serverName.c_str(), replyMsg->address);
std::cout.flush();
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case GetMultiSigKey:
{
BtcNetMsgGetKeyPtr message = BtcNetMsgGetKeyPtr(new BtcNetMsgGetKey());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
std::string pubKey = GetPubKey(message);
if(pubKey.empty())
break;
BtcNetMsgPubKey* replyMsg = new BtcNetMsgPubKey();
memcpy(replyMsg->pubKey, pubKey.c_str(), std::min(pubKey.size(), sizeof(replyMsg->pubKey)));
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case GetBalance:
{
BtcNetMsgGetBalancePtr message = BtcNetMsgGetBalancePtr(new BtcNetMsgGetBalance());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
int64_t balance = GetClientBalance(message);
BtcNetMsgBalance* replyMsg = new BtcNetMsgBalance();
replyMsg->balance = balance;
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case GetTxCount:
{
BtcNetMsgGetTxCountPtr message = BtcNetMsgGetTxCountPtr(new BtcNetMsgGetTxCount());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
int32_t txCount = GetClientTransactionCount(message);
BtcNetMsgTxCount* replyMsg = new BtcNetMsgTxCount();
replyMsg->txCount = txCount;
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case GetTx:
{
BtcNetMsgGetTxPtr message = BtcNetMsgGetTxPtr(new BtcNetMsgGetTx());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
SampleEscrowTransactionPtr tx = GetClientTransaction(message);
if(tx == NULL)
break;
BtcNetMsgTx* replyMsg = new BtcNetMsgTx();
memcpy(replyMsg->txId, tx->txId.c_str(), std::min(tx->txId.size(), sizeof(replyMsg->txId)));
memcpy(replyMsg->toAddress, tx->targetAddr.c_str(), std::min(tx->targetAddr.size(), sizeof(replyMsg->toAddress)));
replyMsg->amount = tx->amountToSend;
replyMsg->type = static_cast<int8_t>(tx->type);
replyMsg->status = static_cast<int8_t>(tx->status);
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case RequestRelease:
{
BtcNetMsgReqWithdrawPtr message = BtcNetMsgReqWithdrawPtr(new BtcNetMsgReqWithdraw());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
bool accepted = RequestEscrowWithdrawal(message);
BtcNetMsgWithdrawReply* replyMsg = new BtcNetMsgWithdrawReply();
replyMsg->accepted = static_cast<int8_t>(accepted);
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
case ReqSignedTx:
{
BtcNetMsgReqSignedTxPtr message = BtcNetMsgReqSignedTxPtr(new BtcNetMsgReqSignedTx());
memcpy(message->data, zmq_msg_data(&request), NetMessageSizes[messageType]);
std::string partiallySignedTx = RequestSignedWithdrawal(message);
if(partiallySignedTx.empty())
break;
BtcNetMsgSignedTx* replyMsg = new BtcNetMsgSignedTx();
memcpy(replyMsg->rawTx, partiallySignedTx.c_str(), std::min(partiallySignedTx.size(), sizeof(replyMsg->rawTx)));
replyPtr = (BtcNetMsg*)replyMsg;
break;
}
default:
std::printf("received malformed message\n");
std::cout.flush();
break;
}
zmq_msg_close(&request);
// Send reply back to client
size_t size = NetMessageSizes[(NetMessageType)replyPtr->MessageType];
zmq_msg_t reply;
zmq_msg_init_size(&reply, size);
zmq_msg_init_data(&reply, replyPtr->data, size, &DeleteNetMsg, replyPtr);
#ifdef OT_USE_ZMQ4
zmq_msg_send(&reply, this->serverSocket, 0);
#else
#ifndef Q_OS_MAC
zmq_send(this->serverSocket, &reply, 0);
#endif
#endif
// note: replyPtr is not deleted on purpose, see DeleteNetMsg()
}
}
