CryptographyTransformStreams.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMove.h"
#include "AsyncStreams.h"
 
namespace SC
{
template <typename T_Cipher>
struct AsyncCipherTransformStreamT : public AsyncTransformStream
{
    T_Cipher cipher;
 
    AsyncCipherTransformStreamT() = default;
 
    template <typename T_Argument>
    explicit AsyncCipherTransformStreamT(T_Argument&& argument) : cipher(forward<T_Argument>(argument))
    {}
 
  private:
    static constexpr size_t BlockSize             = 16;
    static constexpr size_t MaximumUpdateOverhead = BlockSize - 1;
 
    virtual Result onProcess(Span<const char> input, Span<char> output) override
    {
        if (output.sizeInBytes() < BlockSize)
        {
            cipher.reset();
            AsyncWritableStream::emitError(
                Result::Error(AsyncStreamsResultCategory, AsyncStreamsError::CipherOutputBufferTooSmall));
            AsyncTransformStream::afterProcess({}, output);
            return Result(true);
        }
 
        const size_t     inputSize = input.sizeInBytes() < output.sizeInBytes() - MaximumUpdateOverhead
                                         ? input.sizeInBytes()
                                         : output.sizeInBytes() - MaximumUpdateOverhead;
        Span<const char> inputChunk;
        SC_TRY(input.sliceStartLength(0, inputSize, inputChunk));
 
        size_t bytesWritten = 0;
        auto   result       = cipher.update(inputChunk.reinterpret_as_span_of<const uint8_t>(),
                                            output.reinterpret_as_span_of<uint8_t>(), bytesWritten);
        if (not result or bytesWritten > output.sizeInBytes())
        {
            cipher.reset();
            if (result)
                AsyncWritableStream::emitError(
                    Result::Error(AsyncStreamsResultCategory, AsyncStreamsError::CipherInvalidOutputSize));
            else
                AsyncWritableStream::emitError(result);
            AsyncTransformStream::afterProcess({}, output);
            return Result(true);
        }
 
        Span<const char> inputAfter;
        Span<char>       outputAfter;
        SC_TRY(input.sliceStart(inputSize, inputAfter));
        SC_TRY(output.sliceStart(bytesWritten, outputAfter));
        AsyncTransformStream::afterProcess(inputAfter, outputAfter);
        return Result(true);
    }
 
    virtual Result onFinalize(Span<char> output) override
    {
        if (output.sizeInBytes() < BlockSize)
        {
            cipher.reset();
            AsyncWritableStream::emitError(
                Result::Error(AsyncStreamsResultCategory, AsyncStreamsError::CipherOutputBufferTooSmall));
            AsyncTransformStream::afterFinalize(output, true);
            return Result(true);
        }
 
        size_t bytesWritten = 0;
        auto   result       = cipher.finish(output.reinterpret_as_span_of<uint8_t>(), bytesWritten);
        if (not result or bytesWritten > output.sizeInBytes())
        {
            cipher.reset();
            if (result)
                AsyncWritableStream::emitError(
                    Result::Error(AsyncStreamsResultCategory, AsyncStreamsError::CipherInvalidOutputSize));
            else
                AsyncWritableStream::emitError(result);
            AsyncTransformStream::afterFinalize(output, true);
            return Result(true);
        }
 
        Span<char> outputAfter;
        SC_TRY(output.sliceStart(bytesWritten, outputAfter));
        AsyncTransformStream::afterFinalize(outputAfter, true);
        return Result(true);
    }
 
    virtual Result asyncDestroyReadable() override
    {
        cipher.reset();
        return AsyncReadableStream::finishedDestroyingReadable();
    }
 
    virtual Result asyncDestroyWritable() override
    {
        cipher.reset();
        AsyncWritableStream::finishedDestroyingWritable();
        return Result(true);
    }
};
 
template <typename T_Hmac>
struct AsyncHmacWritableStreamT : public AsyncWritableStream
{
    T_Hmac hmac;
 
    AsyncHmacWritableStreamT() = default;
 
    template <typename T_Argument>
    explicit AsyncHmacWritableStreamT(T_Argument&& argument) : hmac(forward<T_Argument>(argument))
    {}
 
  private:
    virtual Result asyncWrite(AsyncBufferView::ID bufferID, Function<void(AsyncBufferView::ID)> callback) override
    {
        Span<const char> data;
        SC_TRY(getBuffersPool().getReadableData(bufferID, data));
        auto result = hmac.add(data.reinterpret_as_span_of<const uint8_t>());
        if (not result)
            hmac.reset();
        finishedWriting(bufferID, move(callback), result);
        return Result(true);
    }
 
    virtual Result asyncDestroyWritable() override
    {
        hmac.reset();
        finishedDestroyingWritable();
        return Result(true);
    }
};
} // namespace SC