C++ CryptoContext类代码示例

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 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 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 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);
  }
}