bls_ies.cpp

Go to the documentation of this file.

// Copyright (c) 2018 The Dash Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include "bls/bls_ies.h"
 
#include "crypto/aes.h"
#include "hash.h"
#include "random.h"
#include "streams.h"
 
template <typename Out>
static bool EncryptBlob(const void* in, size_t inSize, Out& out, const void* symKey, const void* iv)
{
    out.resize(inSize);
 
    AES256CBCEncrypt enc((const unsigned char*)symKey, (const unsigned char*)iv, false);
    int w = enc.Encrypt((const unsigned char*)in, (int)inSize, (unsigned char*)out.data());
    return w == (int)inSize;
}
 
template <typename Out>
static bool DecryptBlob(const void* in, size_t inSize, Out& out, const void* symKey, const void* iv)
{
    out.resize(inSize);
 
    AES256CBCDecrypt enc((const unsigned char*)symKey, (const unsigned char*)iv, false);
    int w = enc.Decrypt((const unsigned char*)in, (int)inSize, (unsigned char*)out.data());
    return w == (int)inSize;
}
 
bool CBLSIESEncryptedBlob::Encrypt(const CBLSPublicKey& peerPubKey, const void* plainTextData, size_t dataSize)
{
    CBLSSecretKey ephemeralSecretKey;
    ephemeralSecretKey.MakeNewKey();
    ephemeralPubKey = ephemeralSecretKey.GetPublicKey();
    GetStrongRandBytes(iv, sizeof(iv));
 
    CBLSPublicKey pk;
    if (!pk.DHKeyExchange(ephemeralSecretKey, peerPubKey)) {
        return false;
    }
 
    std::vector<unsigned char> symKey = pk.ToByteVector();
    symKey.resize(32);
 
    return EncryptBlob(plainTextData, dataSize, data, symKey.data(), iv);
}
 
bool CBLSIESEncryptedBlob::Decrypt(const CBLSSecretKey& secretKey, CDataStream& decryptedDataRet) const
{
    CBLSPublicKey pk;
    if (!pk.DHKeyExchange(secretKey, ephemeralPubKey)) {
        return false;
    }
 
    std::vector<unsigned char> symKey = pk.ToByteVector();
    symKey.resize(32);
 
    return DecryptBlob(data.data(), data.size(), decryptedDataRet, symKey.data(), iv);
}
 
 
bool CBLSIESMultiRecipientBlobs::Encrypt(const std::vector<CBLSPublicKey>& recipients, const BlobVector& _blobs)
{
    if (recipients.size() != _blobs.size()) {
        return false;
    }
 
    InitEncrypt(_blobs.size());
 
    for (size_t i = 0; i < _blobs.size(); i++) {
        if (!Encrypt(i, recipients[i], _blobs[i])) {
            return false;
        }
    }
 
    return true;
}
 
void CBLSIESMultiRecipientBlobs::InitEncrypt(size_t count)
{
    ephemeralSecretKey.MakeNewKey();
    ephemeralPubKey = ephemeralSecretKey.GetPublicKey();
    GetStrongRandBytes(ivSeed.begin(), ivSeed.size());
 
    ivVector.resize(count);
    blobs.resize(count);
    for (size_t i = 0; i < count; i++) {
        ivVector[i] = (i == 0 ? ivSeed : ::SerializeHash(ivVector[i-1]));
    }
}
 
bool CBLSIESMultiRecipientBlobs::Encrypt(size_t idx, const CBLSPublicKey& recipient, const Blob& blob)
{
    assert(idx < blobs.size());
 
    CBLSPublicKey pk;
    if (!pk.DHKeyExchange(ephemeralSecretKey, recipient)) {
        return false;
    }
 
    std::vector<unsigned char> symKey = pk.ToByteVector();
    symKey.resize(32);
 
    return EncryptBlob(blob.data(), blob.size(), blobs[idx], symKey.data(), ivVector[idx].begin());
}
 
bool CBLSIESMultiRecipientBlobs::Decrypt(size_t idx, const CBLSSecretKey& sk, Blob& blobRet) const
{
    if (idx >= blobs.size()) {
        return false;
    }
 
    CBLSPublicKey pk;
    if (!pk.DHKeyExchange(sk, ephemeralPubKey)) {
        return false;
    }
 
    std::vector<unsigned char> symKey = pk.ToByteVector();
    symKey.resize(32);
 
    uint256 iv = ivSeed;
    for (size_t i = 0; i < idx; i++) {
        iv = ::SerializeHash(iv);
    }
 
    return DecryptBlob(blobs[idx].data(), blobs[idx].size(), blobRet, symKey.data(), iv.begin());
}