void WalletSerializerV1::loadTransfers(Common::IInputStream& source, CryptoContext& cryptoContext, uint32_t version) {
uint64_t count = 0;
deserializeEncrypted(count, "transfers_count", cryptoContext, source);
cryptoContext.incIv();
m_transfers.reserve(count);
for (uint64_t i = 0; i < count; ++i) {
uint64_t txId = 0;
deserializeEncrypted(txId, "transaction_id", cryptoContext, source);
cryptoContext.incIv();
WalletTransferDto dto(version);
deserializeEncrypted(dto, "transfer", cryptoContext, source);
cryptoContext.incIv();
WalletTransfer tr;
tr.address = dto.address;
tr.amount = dto.amount;
if (version > 2) {
tr.type = static_cast<WalletTransferType>(dto.type);
} else {
tr.type = WalletTransferType::USUAL;
}
m_transfers.push_back(std::make_pair(txId, tr));
}
}
void WalletSerializer::saveUnlockTransactionsJobs(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
auto& index = m_unlockTransactions.get<TransactionHashIndex>();
auto& wallets = m_walletsContainer.get<TransfersContainerIndex>();
uint64_t jobsCount = index.size();
serializeEncrypted(jobsCount, "unlock_transactions_jobs_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& j: index) {
auto containerIt = wallets.find(j.container);
assert(containerIt != wallets.end());
auto rndIt = m_walletsContainer.project<RandomAccessIndex>(containerIt);
assert(rndIt != m_walletsContainer.get<RandomAccessIndex>().end());
uint64_t walletIndex = std::distance(m_walletsContainer.get<RandomAccessIndex>().begin(), rndIt);
UnlockTransactionJobDto dto;
dto.blockHeight = j.blockHeight;
dto.transactionHash = j.transactionHash;
dto.walletIndex = walletIndex;
serializeEncrypted(dto, "", cryptoContext, destination);
cryptoContext.incIv();
}
}
int main ()
{
printf ("Results of aes_context_test:\n");
try
{
CryptoContext context ("aes.encrypt", key, KEY_BITS);
memset (dst_encrypt_buffer, 0, sizeof dst_decrypt_buffer);
printf ("source: '%s'\n", src_buffer);
printf ("encrypt update: %u\n", context.Update (BUFFER_SIZE, src_buffer, dst_encrypt_buffer));
printf ("dst_encrypt_buffer: ");
for (size_t i=0; i<BUFFER_SIZE; i++)
printf ("%02x", (unsigned char)dst_encrypt_buffer [i]);
printf ("\n");
CryptoContext ("aes.decrypt", key, KEY_BITS).Swap (context);
memset (dst_decrypt_buffer, 0, sizeof dst_decrypt_buffer);
printf ("decrypt update: %u\n", context.Update (BUFFER_SIZE, dst_encrypt_buffer, dst_decrypt_buffer));
printf ("dst_decrypt_buffer: '%s'\n", dst_decrypt_buffer);
}
catch (std::exception& exception)
{
printf ("exception: %s\n", exception.what ());
}
return 0;
}
void WalletSerializerV1::loadFlags(bool& details, bool& cache, Common::IInputStream& source, CryptoContext& cryptoContext) {
deserializeEncrypted(details, "details", cryptoContext, source);
cryptoContext.incIv();
deserializeEncrypted(cache, "cache", cryptoContext, source);
cryptoContext.incIv();
}
void WalletSerializerV1::loadTransactions(Common::IInputStream& source, CryptoContext& cryptoContext) {
uint64_t count = 0;
deserializeEncrypted(count, "transactions_count", cryptoContext, source);
cryptoContext.incIv();
m_transactions.get<RandomAccessIndex>().reserve(count);
for (uint64_t i = 0; i < count; ++i) {
WalletTransactionDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
WalletTransaction tx;
tx.state = dto.state;
tx.timestamp = dto.timestamp;
tx.blockHeight = dto.blockHeight;
tx.hash = dto.hash;
tx.totalAmount = dto.totalAmount;
tx.fee = dto.fee;
tx.creationTime = dto.creationTime;
tx.unlockTime = dto.unlockTime;
tx.extra = dto.extra;
tx.isBase = false;
m_transactions.get<RandomAccessIndex>().push_back(std::move(tx));
}
}
void WalletSerializerV1::loadBalances(Common::IInputStream& source, CryptoContext& cryptoContext) {
deserializeEncrypted(m_actualBalance, "actual_balance", cryptoContext, source);
cryptoContext.incIv();
deserializeEncrypted(m_pendingBalance, "pending_balance", cryptoContext, source);
cryptoContext.incIv();
}
void WalletSerializer::saveFlags(bool saveDetails, bool saveCache, Common::IOutputStream& destination, CryptoContext& cryptoContext) {
serializeEncrypted(saveDetails, "details", cryptoContext, destination);
cryptoContext.incIv();
serializeEncrypted(saveCache, "cache", cryptoContext, destination);
cryptoContext.incIv();
}
void WalletSerializerV1::loadUnlockTransactionsJobs(Common::IInputStream& source, CryptoContext& cryptoContext) {
auto& index = m_unlockTransactions.get<TransactionHashIndex>();
auto& walletsIndex = m_walletsContainer.get<RandomAccessIndex>();
const uint64_t walletsSize = walletsIndex.size();
if (walletsSize) {}
uint64_t jobsCount = 0;
deserializeEncrypted(jobsCount, "unlock_transactions_jobs_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < jobsCount; ++i) {
UnlockTransactionJobDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
assert(dto.walletIndex < walletsSize);
UnlockTransactionJob job;
job.blockHeight = dto.blockHeight;
job.transactionHash = dto.transactionHash;
job.container = walletsIndex[dto.walletIndex].container;
index.insert(std::move(job));
}
}
void WalletSerializer::loadSpentOutputs(Common::IInputStream& source, CryptoContext& cryptoContext) {
auto& index = m_spentOutputs.get<WalletIndex>();
auto& walletsIndex = m_walletsContainer.get<RandomAccessIndex>();
const uint64_t walletsSize = walletsIndex.size();
uint64_t count = 0;
deserializeEncrypted(count, "spent_outputs_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < count; ++i) {
SpentOutputDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
assert(dto.walletIndex < walletsSize);
SpentOutput output;
output.amount = dto.amount;
output.transactionHash = dto.transactionHash;
output.outputInTransaction = dto.outputInTransaction;
output.spendingTransactionHash = dto.spendingTransactionHash;
output.wallet = &walletsIndex[dto.walletIndex];
index.insert(std::move(output));
}
}
void
OutgoingDataQueue::putData(uint32 stamp, const unsigned char *data, size_t datalen)
{
if ( !data || !datalen )
return;
size_t step = 0, offset = 0;
while ( offset < datalen ) {
// remainder and step take care of segmentation
// according to getMaxSendSegmentSize()
size_t remainder = datalen - offset;
step = ( remainder > getMaxSendSegmentSize() ) ?
getMaxSendSegmentSize() : remainder;
CryptoContext* pcc = getOutQueueCryptoContext(getLocalSSRC());
if (pcc == NULL) {
pcc = getOutQueueCryptoContext(0);
if (pcc != NULL) {
pcc = pcc->newCryptoContextForSSRC(getLocalSSRC(), 0, 0L);
if (pcc != NULL) {
pcc->deriveSrtpKeys(0);
setOutQueueCryptoContext(pcc);
}
}
}
OutgoingRTPPkt* packet;
if ( sendInfo.sendCC )
packet = new OutgoingRTPPkt(sendInfo.sendSources,15,data + offset,step, sendInfo.paddinglen, pcc);
else
packet = new OutgoingRTPPkt(data + offset,step,sendInfo.paddinglen, pcc);
packet->setPayloadType(getCurrentPayloadType());
packet->setSeqNum(sendInfo.sendSeq++);
packet->setTimestamp(stamp + getInitialTimestamp());
packet->setSSRCNetwork(getLocalSSRCNetwork());
if ( (0 == offset) && getMark() ) {
packet->setMarker(true);
setMark(false);
} else {
packet->setMarker(false);
}
if (pcc != NULL) {
packet->protect(getLocalSSRC(), pcc);
}
// insert the packet into the "tail" of the sending queue
sendLock.writeLock();
OutgoingRTPPktLink *link =
new OutgoingRTPPktLink(packet,sendLast,NULL);
if (sendLast)
sendLast->setNext(link);
else
sendFirst = link;
sendLast = link;
sendLock.unlock();
offset += step;
}
}
void WalletSerializer::saveBalances(Common::IOutputStream& destination, bool saveCache, CryptoContext& cryptoContext) {
uint64_t actual = saveCache ? m_actualBalance : 0;
uint64_t pending = saveCache ? m_pendingBalance : 0;
serializeEncrypted(actual, "actual_balance", cryptoContext, destination);
cryptoContext.incIv();
serializeEncrypted(pending, "pending_balance", cryptoContext, destination);
cryptoContext.incIv();
}
void WalletSerializer::saveTransactions(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
uint64_t count = m_transactions.size();
serializeEncrypted(count, "transactions_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& tx: m_transactions) {
WalletTransactionDto dto(tx);
serializeEncrypted(dto, "", cryptoContext, destination);
cryptoContext.incIv();
}
}
void WalletSerializerV1::loadObsoleteSpentOutputs(Common::IInputStream& source, CryptoContext& cryptoContext) {
uint64_t count = 0;
deserializeEncrypted(count, "spent_outputs_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < count; ++i) {
ObsoleteSpentOutputDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
}
}
void WalletSerializerV1::loadObsoleteChange(Common::IInputStream& source, CryptoContext& cryptoContext) {
uint64_t count = 0;
deserializeEncrypted(count, "changes_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < count; i++) {
ObsoleteChangeDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
}
}
void WalletSerializer::loadChange(Common::IInputStream& source, CryptoContext& cryptoContext) {
uint64_t count = 0;
deserializeEncrypted(count, "changes_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < count; i++) {
ChangeDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
m_change[dto.txHash] = dto.amount;
}
}
void WalletSerializer::saveChange(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
uint64_t count = m_change.size();
serializeEncrypted(count, "changes_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& kv: m_change) {
ChangeDto dto;
dto.txHash = kv.first;
dto.amount = kv.second;
serializeEncrypted(dto, "", cryptoContext, destination);
cryptoContext.incIv();
}
}
void WalletSerializer::saveTransfers(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
uint64_t count = m_transfers.size();
serializeEncrypted(count, "transfers_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& kv: m_transfers) {
uint64_t txId = kv.first;
WalletTransferDto tr(kv.second);
serializeEncrypted(txId, "transaction_id", cryptoContext, destination);
cryptoContext.incIv();
serializeEncrypted(tr, "transfer", cryptoContext, destination);
cryptoContext.incIv();
}
}
const char * scytale_key_derivate(RedCryptoKeyHandle * handle, const uint8_t * derivator, size_t len)
{
SCOPED_TRACE;
CHECK_HANDLE_R(handle, "");
std::unique_ptr<uint8_t[]> normalized_derivator_gc;
auto const new_derivator = CryptoContext::get_normalized_derivator(
normalized_derivator_gc, {derivator, len});
CryptoContext cctx;
cctx.old_encryption_scheme = false;
cctx.one_shot_encryption_scheme = false;
cctx.set_master_key(handle->master);
cctx.get_derived_key(handle->derivated, new_derivator);
hash_to_hashhex(handle->derivated, handle->derivatedhex);
return handle->derivatedhex;
}
void WalletSerializer::saveTransfersSynchronizer(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
std::stringstream stream;
m_synchronizer.save(stream);
stream.flush();
std::string plain = stream.str();
serializeEncrypted(plain, "transfers_synchronizer", cryptoContext, destination);
cryptoContext.incIv();
}
void WalletSerializer::loadWallets(Common::IInputStream& source, CryptoContext& cryptoContext) {
auto& index = m_walletsContainer.get<RandomAccessIndex>();
uint64_t count = 0;
deserializeEncrypted(count, "wallets_count", cryptoContext, source);
cryptoContext.incIv();
bool isTrackingMode;
for (uint64_t i = 0; i < count; ++i) {
WalletRecordDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
if (i == 0) {
isTrackingMode = dto.spendSecretKey == NULL_SECRET_KEY;
} else if ((isTrackingMode && dto.spendSecretKey != NULL_SECRET_KEY) || (!isTrackingMode && dto.spendSecretKey == NULL_SECRET_KEY)) {
throw std::system_error(make_error_code(error::BAD_ADDRESS), "All addresses must be whether tracking or not");
}
if (dto.spendSecretKey != NULL_SECRET_KEY) {
Crypto::PublicKey restoredPublicKey;
bool r = Crypto::secret_key_to_public_key(dto.spendSecretKey, restoredPublicKey);
if (!r || dto.spendPublicKey != restoredPublicKey) {
throw std::system_error(make_error_code(error::WRONG_PASSWORD), "Restored spend public key doesn't correspond to secret key");
}
} else {
if (!Crypto::check_key(dto.spendPublicKey)) {
throw std::system_error(make_error_code(error::WRONG_PASSWORD), "Public spend key is incorrect");
}
}
WalletRecord wallet;
wallet.spendPublicKey = dto.spendPublicKey;
wallet.spendSecretKey = dto.spendSecretKey;
wallet.actualBalance = dto.actualBalance;
wallet.pendingBalance = dto.pendingBalance;
wallet.creationTimestamp = static_cast<time_t>(dto.creationTimestamp);
wallet.container = reinterpret_cast<CryptoNote::ITransfersContainer*>(i); //dirty hack. container field must be unique
index.push_back(wallet);
}
}
void WalletSerializerV1::loadTransfersSynchronizer(Common::IInputStream& source, CryptoContext& cryptoContext) {
std::string deciphered;
deserializeEncrypted(deciphered, "transfers_synchronizer", cryptoContext, source);
cryptoContext.incIv();
std::stringstream stream(deciphered);
deciphered.clear();
m_synchronizer.load(stream);
}
void WalletSerializer::saveWallets(Common::IOutputStream& destination, bool saveCache, CryptoContext& cryptoContext) {
auto& index = m_walletsContainer.get<RandomAccessIndex>();
uint64_t count = index.size();
serializeEncrypted(count, "wallets_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& w: index) {
WalletRecordDto dto;
dto.spendPublicKey = w.spendPublicKey;
dto.spendSecretKey = w.spendSecretKey;
dto.pendingBalance = saveCache ? w.pendingBalance : 0;
dto.actualBalance = saveCache ? w.actualBalance : 0;
dto.creationTimestamp = static_cast<uint64_t>(w.creationTimestamp);
serializeEncrypted(dto, "", cryptoContext, destination);
cryptoContext.incIv();
}
}
CryptoContextWrapper(
get_hmac_key_prototype * hmac_fn, get_trace_key_prototype * trace_fn,
bool with_encryption, bool with_checksum,
bool old_encryption_scheme, bool one_shot_encryption_scheme,
char const * filename_derivatator)
{
cctx.set_get_hmac_key_cb(hmac_fn);
cctx.set_get_trace_key_cb(trace_fn);
cctx.set_trace_type(
with_encryption
? TraceType::cryptofile
: with_checksum
? TraceType::localfile_hashed
: TraceType::localfile);
cctx.old_encryption_scheme = old_encryption_scheme;
cctx.one_shot_encryption_scheme = one_shot_encryption_scheme;
size_t base_len = 0;
char const * base = basename_len(filename_derivatator, base_len);
cctx.set_master_derivator({base, base_len});
}
void WalletSerializer::saveSpentOutputs(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
auto& index = m_spentOutputs.get<WalletIndex>();
uint64_t outsCount = index.size();
serializeEncrypted(outsCount, "spent_outputs_count", cryptoContext, destination);
cryptoContext.incIv();
for (const auto& o: index) {
auto it = m_walletsContainer.get<RandomAccessIndex>().iterator_to(*o.wallet);
uint64_t walletIndex = std::distance(m_walletsContainer.get<RandomAccessIndex>().begin(), it);
SpentOutputDto dto;
dto.amount = o.amount;
dto.transactionHash = o.transactionHash;
dto.outputInTransaction = o.outputInTransaction;
dto.walletIndex = walletIndex;
dto.spendingTransactionHash = o.spendingTransactionHash;
serializeEncrypted(dto, "", cryptoContext, destination);
cryptoContext.incIv();
}
}
void WalletSerializer::loadTransfers(Common::IInputStream& source, CryptoContext& cryptoContext) {
uint64_t count = 0;
deserializeEncrypted(count, "transfers_count", cryptoContext, source);
cryptoContext.incIv();
m_transfers.reserve(count);
for (uint64_t i = 0; i < count; ++i) {
uint64_t txId = 0;
deserializeEncrypted(txId, "transaction_id", cryptoContext, source);
cryptoContext.incIv();
WalletTransferDto dto;
deserializeEncrypted(dto, "transfer", cryptoContext, source);
cryptoContext.incIv();
WalletTransfer tr;
tr.address = dto.address;
tr.amount = dto.amount;
m_transfers.push_back(std::make_pair(txId, tr));
}
}
void WalletSerializer::loadWallets(Common::IInputStream& source, CryptoContext& cryptoContext) {
auto& index = m_walletsContainer.get<RandomAccessIndex>();
uint64_t count = 0;
deserializeEncrypted(count, "wallets_count", cryptoContext, source);
cryptoContext.incIv();
for (uint64_t i = 0; i < count; ++i) {
WalletRecordDto dto;
deserializeEncrypted(dto, "", cryptoContext, source);
cryptoContext.incIv();
WalletRecord wallet;
wallet.spendPublicKey = dto.spendPublicKey;
wallet.spendSecretKey = dto.spendSecretKey;
wallet.actualBalance = dto.actualBalance;
wallet.pendingBalance = dto.pendingBalance;
wallet.creationTimestamp = static_cast<time_t>(dto.creationTimestamp);
wallet.container = reinterpret_cast<CryptoNote::ITransfersContainer*>(i); //dirty hack. container field must be unique
index.push_back(wallet);
}
}
bool CtZrtpStream::srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part)
{
CryptoContext* recvCryptoContext;
CryptoContext* senderCryptoContext;
CryptoContextCtrl* recvCryptoContextCtrl;
CryptoContextCtrl* senderCryptoContextCtrl;
int cipher;
int authn;
int authKeyLen;
if (secrets->authAlgorithm == Sha1) {
authn = SrtpAuthenticationSha1Hmac;
authKeyLen = 20;
}
if (secrets->authAlgorithm == Skein) {
authn = SrtpAuthenticationSkeinHmac;
authKeyLen = 32;
}
if (secrets->symEncAlgorithm == Aes)
cipher = SrtpEncryptionAESCM;
if (secrets->symEncAlgorithm == TwoFish)
cipher = SrtpEncryptionTWOCM;
role = secrets->role;
if (part == ForSender) {
// To encrypt packets: intiator uses initiator keys,
// responder uses responder keys
// Create a "half baked" crypto context first and store it. This is
// the main crypto context for the sending part of the connection.
if (secrets->role == Initiator) {
senderCryptoContext =
new CryptoContext(0, // SSRC (used for lookup)
0, // Roll-Over-Counter (ROC)
0L, // keyderivation << 48,
cipher, // encryption algo
authn, // authtentication algo
(unsigned char*)secrets->keyInitiator, // Master Key
secrets->initKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltInitiator, // Master Salt
secrets->initSaltLen / 8, // Master Salt length
secrets->initKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->initSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag lenA
senderCryptoContextCtrl =
new CryptoContextCtrl(0, // SSRC (used for lookup)
cipher, // encryption algo
authn, // authtication algo
(unsigned char*)secrets->keyInitiator, // Master Key
secrets->initKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltInitiator, // Master Salt
secrets->initSaltLen / 8, // Master Salt length
secrets->initKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->initSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
}
else {
senderCryptoContext =
new CryptoContext(0, // SSRC (used for lookup)
0, // Roll-Over-Counter (ROC)
0L, // keyderivation << 48,
cipher, // encryption algo
authn, // authtentication algo
(unsigned char*)secrets->keyResponder, // Master Key
secrets->respKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltResponder, // Master Salt
secrets->respSaltLen / 8, // Master Salt length
secrets->respKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->respSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
senderCryptoContextCtrl =
new CryptoContextCtrl(0, // SSRC (used for lookup)
cipher, // encryption algo
authn, // authtication algo
(unsigned char*)secrets->keyResponder, // Master Key
secrets->respKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltResponder, // Master Salt
secrets->respSaltLen / 8, // Master Salt length
secrets->respKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->respSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
}
if (senderCryptoContext == NULL) {
return false;
}
senderCryptoContext->deriveSrtpKeys(0L);
sendSrtp = senderCryptoContext;
senderCryptoContextCtrl->deriveSrtcpKeys();
sendSrtcp = senderCryptoContextCtrl;
}
if (part == ForReceiver) {
// To decrypt packets: intiator uses responder keys,
// responder initiator keys
// See comment above.
if (secrets->role == Initiator) {
recvCryptoContext =
new CryptoContext(0, // SSRC (used for lookup)
0, // Roll-Over-Counter (ROC)
0L, // keyderivation << 48,
cipher, // encryption algo
authn, // authtentication algo
(unsigned char*)secrets->keyResponder, // Master Key
secrets->respKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltResponder, // Master Salt
secrets->respSaltLen / 8, // Master Salt length
secrets->respKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->respSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
recvCryptoContextCtrl =
new CryptoContextCtrl(0, // SSRC (used for lookup)
cipher, // encryption algo
authn, // authtication algo
(unsigned char*)secrets->keyResponder, // Master Key
secrets->respKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltResponder, // Master Salt
secrets->respSaltLen / 8, // Master Salt length
secrets->respKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->respSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
}
else {
recvCryptoContext =
new CryptoContext(0, // SSRC (used for lookup)
0, // Roll-Over-Counter (ROC)
0L, // keyderivation << 48,
cipher, // encryption algo
authn, // authtentication algo
(unsigned char*)secrets->keyInitiator, // Master Key
secrets->initKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltInitiator, // Master Salt
secrets->initSaltLen / 8, // Master Salt length
secrets->initKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->initSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
recvCryptoContextCtrl =
new CryptoContextCtrl(0, // SSRC (used for lookup)
cipher, // encryption algo
authn, // authtication algo
(unsigned char*)secrets->keyInitiator, // Master Key
secrets->initKeyLen / 8, // Master Key length
(unsigned char*)secrets->saltInitiator, // Master Salt
secrets->initSaltLen / 8, // Master Salt length
secrets->initKeyLen / 8, // encryption keyl
authKeyLen, // authentication key len
secrets->initSaltLen / 8, // session salt len
secrets->srtpAuthTagLen / 8); // authentication tag len
}
if (recvCryptoContext == NULL) {
return false;
}
recvCryptoContext->deriveSrtpKeys(0L);
recvSrtp = recvCryptoContext;
recvCryptoContextCtrl->deriveSrtcpKeys();
recvSrtcp = recvCryptoContextCtrl;
supressCounter = 0; // supress SRTP warnings for some packets after we switch to SRTP
}
if (zrtpHashMatch && recvSrtp != NULL && sendSrtp != NULL) {
sdesActive = false;
}
return true;
}
void WalletSerializerV1::loadPublicKey(Common::IInputStream& source, CryptoContext& cryptoContext) {
deserializeEncrypted(m_viewPublicKey, "public_key", cryptoContext, source);
cryptoContext.incIv();
}
void WalletSerializer::saveSecretKey(Common::IOutputStream& destination, CryptoContext& cryptoContext) {
serializeEncrypted(m_viewSecretKey, "secret_key", cryptoContext, destination);
cryptoContext.incIv();
}
void WalletSerializerV1::loadSecretKey(Common::IInputStream& source, CryptoContext& cryptoContext) {
deserializeEncrypted(m_viewSecretKey, "secret_key", cryptoContext, source);
cryptoContext.incIv();
}