将加密的消息拆分成块并再次组合在一起

Question

I want to send GPG encrypted data via GET request of known format.

Issue #1: Data block size in the request is limited (4096 symbols), and it is not enough for a typical GPG message. So, I need to chunk it.

Issue #2: Chunks may be sent in the wrong order. Each chunk must have a unique message ID and serial number, so the messages can be put together.

GPG has the method to send encrypted data in text format (armoring). RFC 2440 standard allows chunking armored messages:

BEGIN PGP MESSAGE, PART X/Y

Used for multi-part messages, where the armor is split amongst Y parts, and this is the Xth part out of Y.

BEGIN PGP MESSAGE, PART X

Used for multi-part messages, where this is the Xth part of an unspecified number of parts. Requires the MESSAGE-ID Armor Header to be used.

But, unfortunately, I've found no evidence that this feature is implemented in GPG. And no word about chunking of public keys, which, actually, can be huge too. So I turned down the idea of using native GPG armors for chunking.

My current home-made solution: binary encrypted data are splitted into chunks, then each chunk is put into a block, which contains UUID (MessageID analog), the serial number of the block, the total number of blocks, and CRC checksum of the block. Like that:

[ UUID ][ Number ][ Total ][ Chunk of encrypted data ][ Checksum ]

Putting the message together out of that blocks is a bigger challenge, but doable as well. But I want more clear solution, preferably on C++.

Could you help me?

Answer 1

Qt provides very simple methods for data serialization. I created a class to chunk, store, and rebuild binary data, and for now I don't think I need something more simple.

But, if someone knows a better solution, please share it with me.

#include <QByteArrayView>
#include <QDataStream>
#include <QException>
#include <QUuid>

enum CHUNKER {
    MESSAGE_READY = 0,
    BLOCK_ADDED
};

struct ChunkedMessage {
    QUuid UUID;
    QByteArray Data;
};

class Chunker {
public:
    Chunker();
    ~Chunker();
    static quint16 GetChecksum(QByteArray *Block);
    static QByteArrayList ArmorData(QByteArray *Data, qsizetype *ChunkSize);
    CHUNKER AddBlock(QByteArray *Block, ChunkedMessage *Message);
private:
    struct MessageBlock {
        QUuid UUID;
        quint32 Number;
        quint32 Total;
        QByteArray Data;
    };
    QMap<QUuid, quint32> Sizes;
    QMap<QUuid, QMap<quint32, Chunker::MessageBlock>*> Stack;
    MessageBlock DearmorChunk(QByteArray *Block);
    bool CheckIntegrity(QUuid *UUID, QByteArray *Reconstructed);
};

Chunker::Chunker() { }

Chunker::~Chunker() { }

quint16 Chunker::GetChecksum(QByteArray *Block) { return qChecksum(QByteArrayView(*Block), Qt::ChecksumIso3309); }

QByteArrayList Chunker::ArmorData(QByteArray *Data, qsizetype *ChunkSize) {
    QByteArrayList Result;
    QUuid UUID = QUuid::createUuid();
    qsizetype RealChunkSize = (*ChunkSize) - sizeof(UUID.toRfc4122()) - sizeof(quint32) - sizeof(quint32) - sizeof(quint16);
    const quint32 ChunkCount = ((*Data).length() / RealChunkSize) + 1;
    for (auto Pos = 0; Pos < ChunkCount; Pos++) {
        QByteArray Block;
        QDataStream Stream(&Block, QIODeviceBase::WriteOnly);
        Stream << UUID.toRfc4122() << (Pos + 1) << ChunkCount << (*Data).mid(Pos * RealChunkSize, RealChunkSize);
        Stream << Chunker::GetChecksum(&Block);
        Result.push_back(Block);
    }
    return Result;
}

Chunker::MessageBlock Chunker::DearmorChunk(QByteArray *Block) {
    Chunker::MessageBlock Result;
    QDataStream Stream(Block, QIODeviceBase::ReadOnly);
    QByteArray ClearBlock = (*Block).chopped(sizeof(quint16));
    QByteArray BytesUUID;
    quint16 Checksum;
    Stream >> BytesUUID >> Result.Number >> Result.Total >> Result.Data >> Checksum;
    Result.UUID = QUuid::fromRfc4122(QByteArrayView(BytesUUID));
    if (Chunker::GetChecksum(&ClearBlock) != Checksum) throw std::runtime_error("Checksums are not equal");
    return Result;
}

bool Chunker::CheckIntegrity(QUuid *UUID, QByteArray *Reconstructed) {
    quint32 Size = this->Sizes[*UUID];
    if (this->Stack[*UUID]->size() > Size) throw std::runtime_error("Corrupted message blocks");
    if (this->Stack[*UUID]->size() < Size) return false;
    for (quint32 Counter = 0; Counter < Size; Counter++) {
        if (!(this->Stack[*UUID]->contains(Counter + 1))) return false;
        (*Reconstructed).append((*(this->Stack[*UUID]))[Counter + 1].Data);
    }
    return true;
}

CHUNKER Chunker::AddBlock(QByteArray *Block, ChunkedMessage *Message) {
    Chunker::MessageBlock DecodedBlock = Chunker::DearmorChunk(Block);
    if (!this->Sizes.contains(DecodedBlock.UUID)) {
        this->Sizes[(QUuid)DecodedBlock.UUID] = (quint32)DecodedBlock.Total;
        this->Stack[(QUuid)DecodedBlock.UUID] = new QMap<quint32, Chunker::MessageBlock>;
    }
    (*(this->Stack[DecodedBlock.UUID]))[(quint32)(DecodedBlock.Number)] = Chunker::MessageBlock(DecodedBlock);
    QByteArray ReconstructedData;
    if (this->CheckIntegrity(&DecodedBlock.UUID, &ReconstructedData)) {
        (*Message).UUID = (QUuid)(DecodedBlock.UUID);
        (*Message).Data = (QByteArray)ReconstructedData;
        this->Sizes.remove(DecodedBlock.UUID);
        delete this->Stack[DecodedBlock.UUID];
        this->Stack.remove(DecodedBlock.UUID);
        return CHUNKER::MESSAGE_READY;
    }
    return CHUNKER::BLOCK_ADDED;
}