crypto1.cpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com>
 * Copyright (c) 2021 Gothel Software e.K.
 * Copyright (c) 2021 ZAFENA AB
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#include <cipherpack/cipherpack.hpp>
 
#include <cstdint>
#include "jau/byte_util.hpp"
#include <jau/debug.hpp>
#include <jau/io/file_util.hpp>
 
using namespace cipherpack;
 
// static uint32_t to_uint32_t(const Botan::BigInt& v) const { return v.to_u32bit(); }
 
static Botan::BigInt to_BigInt(const uint64_t & v) {
    return Botan::BigInt::from_u64(v);
}
 
static uint64_t to_uint64_t(const Botan::BigInt& v) {
    if( v.is_negative() ) {
        throw Botan::Encoding_Error("BigInt::to_u64bit: Number is negative");
    }
    if( v.bits() > 64 ) {
        throw Botan::Encoding_Error("BigInt::to_u64bit: Number is too big to convert");
    }
    uint64_t out = 0;
    for(size_t i = 0; i < 8; ++i) {
        out = (out << 8) | v.byte_at(7-i);
    }
    return out;
}
 
static int64_t to_positive_int64_t(const Botan::BigInt& v) {
    if( v.is_negative() ) {
        throw Botan::Encoding_Error("BigInt::to_positive_int64_t: Number is negative");
    }
    if( v.bits() > 63 ) {
        throw Botan::Encoding_Error("BigInt::to_positive_int64_t: Number is too big to convert");
    }
    uint64_t out = 0;
    for(size_t i = 0; i < 8; ++i) {
        out = (out << 8) | v.byte_at(7-i);
    }
    return static_cast<int64_t>( out );
}
 
static std::vector<uint8_t> to_OctetString(const std::string& s) {
    return std::vector<uint8_t>( s.begin(), s.end() );
}
 
static std::string to_string(const std::vector<uint8_t>& v) {
    return std::string(reinterpret_cast<const char*>(v.data()), v.size());
}
 
class WrappingCipherpackListener : public CipherpackListener {
    public:
        CipherpackListenerRef parent;
 
        WrappingCipherpackListener(CipherpackListenerRef parent_) // NOLINT(modernize-pass-by-value)
        : parent( parent_ ) {} // NOLINT(performance-unnecessary-value-param)
 
        void notifyError(const bool decrypt_mode, const PackHeader& header, const std::string& msg) noexcept override {
            parent->notifyError(decrypt_mode, header, msg);
        }
 
        bool notifyHeader(const bool decrypt_mode, const PackHeader& header) noexcept override {
            return parent->notifyHeader(decrypt_mode, header);
        }
 
        bool notifyProgress(const bool decrypt_mode, const uint64_t plaintext_size, const uint64_t bytes_processed) noexcept override {
            return parent->notifyProgress(decrypt_mode, plaintext_size, bytes_processed);
        }
 
        void notifyEnd(const bool decrypt_mode, const PackHeader& header) noexcept override {
            parent->notifyEnd(decrypt_mode, header);
        }
 
        bool getSendContent(const bool decrypt_mode) const noexcept override {
            return parent->getSendContent(decrypt_mode);
        }
 
        bool contentProcessed(const bool decrypt_mode, const content_type ctype, cipherpack::secure_vector<uint8_t>& data, const bool is_final) noexcept override {
            return parent->contentProcessed(decrypt_mode, ctype, data, is_final);
        }
 
        ~WrappingCipherpackListener() noexcept override = default;
 
        std::string toString() const noexcept override { return "WrappingCipherpackListener["+jau::toHexString(this)+"]"; }
};
 
typedef std::function<bool (secure_vector<uint8_t>& /* data */, bool /* is_final */)> _StreamConsumerFunc;
 
static uint64_t _read_stream(jau::io::ByteStream& in,
                             cipherpack::secure_vector<uint8_t>& buffer,
                             const _StreamConsumerFunc& consumer_fn) noexcept {
    uint64_t total = 0;
    bool has_more;
    do {
        if( in.available(1) ) { // at least one byte to stream, also considers eof
            buffer.resize(buffer.capacity());
            const uint64_t got = in.read(buffer.data(), buffer.capacity());
 
            buffer.resize(got);
            total += got;
            has_more = 1 <= got && !in.fail() && ( !in.hasContentSize() || total < in.contentSize() );
            try {
                if( !consumer_fn(buffer, !has_more) ) {
                    break; // end streaming
                }
            } catch (std::exception &e) {
                jau_ERR_PRINT("read_stream: Caught exception: %s", e.what());
                break; // end streaming
            }
        } else {
            has_more = false;
            buffer.resize(0);
            consumer_fn(buffer, true); // forced final, zero size
        }
    } while( has_more );
    return total;
}
 
static uint64_t _read_buffer(jau::io::ByteStream& in,
                             secure_vector<uint8_t>& buffer) noexcept {
    if( in.available(1) ) { // at least one byte to stream, also considers eof
        buffer.resize(buffer.capacity());
        const uint64_t got = in.read(buffer.data(), buffer.capacity());
        buffer.resize(got);
        return got;
    }
    return 0;
}
 
static uint64_t _read_stream(jau::io::ByteStream& in,
                             cipherpack::secure_vector<uint8_t>& buffer1, secure_vector<uint8_t>& buffer2,
                             const _StreamConsumerFunc& consumer_fn) noexcept {
    secure_vector<uint8_t>* buffers[] = { &buffer1, &buffer2 };
    bool eof[] = { false, false };
 
    bool eof_read = false;
    uint64_t total_send = 0;
    uint64_t total_read = 0;
    int idx = 0;
    // fill 1st buffer upfront
    {
        uint64_t got = _read_buffer(in, *buffers[idx]);
        total_read += got;
        eof_read = 0 == got || in.fail() || ( in.hasContentSize() && total_read >= in.contentSize() );
        eof[idx] = eof_read;
        ++idx;
    }
 
    // - buffer_idx was filled
    // - buffer_idx++
    //
    // - while !eof_send do
    //   - read buffer_idx if not eof_read,
    //     - set eof[buffer_idx+1]=true if zero bytes
    //   - buffer_idx++
    //   - sent buffer_idx
    //
    bool eof_send = false;
    while( !eof_send ) {
        int bidx_next = ( idx + 1 ) % 2;
        if( !eof_read ) {
            uint64_t got = _read_buffer(in, *buffers[idx]);
            total_read += got;
            eof_read = 0 == got || in.fail() || ( in.hasContentSize() && total_read >= in.contentSize() );
            eof[idx] = eof_read;
            if( 0 == got ) {
                // read-ahead eof propagation if read zero bytes,
                // hence next consumer_fn() will send last bytes with is_final=true
                eof[bidx_next] = true;
            }
        }
        idx = bidx_next;
 
        secure_vector<uint8_t>* buffer = buffers[idx];
        eof_send = eof[idx];
        total_send += buffer->size();
        try {
            if( !consumer_fn(*buffer, eof_send) ) {
                return total_send; // end streaming
            }
        } catch (std::exception &e) {
            jau_ERR_PRINT("read_stream: Caught exception: %s", e.what());
            return total_send; // end streaming
        }
    }
    return total_send;
}
 
static std::vector<uint8_t> _fingerprint_public(const Botan::Public_Key& key, Botan::HashFunction& hash_func) {
    std::vector<uint8_t> fp( hash_func.output_length() );
    hash_func.clear();
    hash_func.update( key.subject_public_key() );
    hash_func.final( fp.data() );
    return fp;
}
 
static PackHeader encryptThenSign_Impl(const CryptoConfig& crypto_cfg,
                                       const std::vector<std::string>& enc_pub_keys,
                                       const std::string& sign_sec_key_fname, const jau::io::secure_string& passphrase,
                                       jau::io::ByteStream& source,
                                       const std::string& target_path, const std::string& subject,
                                       const std::string& plaintext_version,
                                       const std::string& plaintext_version_parent,
                                       CipherpackListenerRef listener,
                                       const std::string_view& plaintext_hash_algo) {
    const bool decrypt_mode = false;
    environment::get();
    const jau::fraction_timespec ts_creation = jau::getWallClockTime();
 
    PackHeader header(target_path,
                      source.contentSize(),
                      ts_creation,
                      subject,
                      plaintext_version, plaintext_version_parent,
                      crypto_cfg,
                      std::vector<uint8_t>(),
                      std::vector<std::vector<uint8_t>>(),
                      -1 /* term_key_fingerprint_used_idx */,
                      false /* valid */);
 
    if( nullptr == listener ) {
        jau_ERR_PRINT2("Encrypt failed: Listener is nullptr for source %s", source.toString());
        return header;
    }
 
    if( source.fail() ) {
        listener->notifyError(decrypt_mode, header, "Source has an error "+source.toString());
        return header;
    }
    const bool has_plaintext_size = source.hasContentSize();
    uint64_t plaintext_size = has_plaintext_size ? source.contentSize() : 0;
 
    if( !crypto_cfg.valid() ) {
        listener->notifyError(decrypt_mode, header, "CryptoConfig incomplete "+crypto_cfg.to_string());
        return header;
    }
 
    const jau::fraction_timespec _t0 = jau::getMonotonicTime();
 
    uint64_t out_bytes_header = 0;
 
    try {
        std::unique_ptr<Botan::HashFunction> plaintext_hash_func = nullptr;
        if( !plaintext_hash_algo.empty() ) {
            const std::string plaintext_hash_algo_s(plaintext_hash_algo);
            plaintext_hash_func = Botan::HashFunction::create(plaintext_hash_algo_s);
            if( nullptr == plaintext_hash_func ) {
                listener->notifyError(decrypt_mode, header, "Plaintext hash algo '"+plaintext_hash_algo_s+"' not available");
                return header;
            }
        }
        std::unique_ptr<Botan::HashFunction> fingerprint_hash_func = Botan::HashFunction::create(crypto_cfg.pk_fingerprt_hash_algo);
        if( nullptr == fingerprint_hash_func ) {
            listener->notifyError(decrypt_mode, header, "Fingerprint hash algo '"+crypto_cfg.pk_fingerprt_hash_algo+"' not available");
            return header;
        }
 
        Botan::RandomNumberGenerator& rng = Botan::system_rng();
 
        std::shared_ptr<Botan::Private_Key> sign_sec_key = load_private_key(sign_sec_key_fname, passphrase);
        if( !sign_sec_key ) {
            return header;
        }
 
        const Botan::OID sym_enc_algo_oid = Botan::OID::from_string(crypto_cfg.sym_enc_algo);
        if( sym_enc_algo_oid.empty() ) {
            listener->notifyError(decrypt_mode, header, "No OID defined for cypher algo '"+crypto_cfg.sym_enc_algo+"'");
            return header;
        }
        std::shared_ptr<Botan::AEAD_Mode> aead = Botan::AEAD_Mode::create(crypto_cfg.sym_enc_algo, Botan::ENCRYPTION);
        if(!aead) {
           listener->notifyError(decrypt_mode, header, "AEAD algo '"+crypto_cfg.sym_enc_algo+"' not available");
           return header;
        }
        cipherpack::secure_vector<uint8_t> plain_sym_key = rng.random_vec(aead->key_spec().maximum_keylength());
        cipherpack::secure_vector<uint8_t> nonce = rng.random_vec(crypto_cfg.sym_enc_nonce_bytes);
        std::vector<uint8_t> sender_fingerprint = _fingerprint_public(*sign_sec_key, *fingerprint_hash_func);
 
        struct recevr_data_t {
            std::shared_ptr<Botan::Public_Key> pub_key;
            std::vector<uint8_t> fingerprint;
            std::vector<uint8_t> encrypted_sym_key;
            std::vector<uint8_t> encrypted_nonce;
        };
        std::vector<recevr_data_t> recevr_data_list;
        std::vector<std::vector<uint8_t>> recevr_fingerprints;
 
        for( const std::string& pub_key_fname : enc_pub_keys ) {
            recevr_data_t recevr_data;
 
            recevr_data.pub_key = load_public_key(pub_key_fname);
            if( !recevr_data.pub_key ) {
                listener->notifyError(decrypt_mode, header, "Loading pub-key file '"+pub_key_fname+"' failed");
                return header;
            }
            Botan::PK_Encryptor_EME enc(*recevr_data.pub_key, rng, crypto_cfg.pk_enc_padding_algo+"(" + crypto_cfg.pk_enc_hash_algo + ")");
            recevr_data.fingerprint = _fingerprint_public(*recevr_data.pub_key, *fingerprint_hash_func);
            recevr_fingerprints.push_back(recevr_data.fingerprint);
            recevr_data.encrypted_sym_key = enc.encrypt(plain_sym_key, rng);
            recevr_data.encrypted_nonce = enc.encrypt(nonce, rng);
            recevr_data_list.push_back(recevr_data);
        }
 
        std::vector<uint8_t> sender_signature;
        {
            cipherpack::secure_vector<uint8_t> header_buffer;
            header_buffer.reserve(Constants::buffer_size);
 
            // DER-Header-1
            header_buffer.clear();
            {
                Botan::DER_Encoder der(header_buffer);
                der.start_sequence()
                   .encode( to_OctetString( Constants::package_magic ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( target_path ), Botan::ASN1_Type::OctetString )
                   .encode( to_BigInt(  plaintext_size ), Botan::ASN1_Type::Integer )
                   .encode( to_BigInt( static_cast<uint64_t>( ts_creation.tv_sec ) ), Botan::ASN1_Type::Integer )
                   .encode( to_BigInt( static_cast<uint64_t>( ts_creation.tv_nsec ) ), Botan::ASN1_Type::Integer )
                   .encode( to_OctetString( subject ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( plaintext_version ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( plaintext_version_parent ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( crypto_cfg.pk_type ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( crypto_cfg.pk_fingerprt_hash_algo ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( crypto_cfg.pk_enc_padding_algo ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( crypto_cfg.pk_enc_hash_algo ), Botan::ASN1_Type::OctetString )
                   .encode( to_OctetString( crypto_cfg.pk_sign_algo ), Botan::ASN1_Type::OctetString )
                   .encode( sym_enc_algo_oid )
                   .encode( sender_fingerprint, Botan::ASN1_Type::OctetString )
                   .encode( recevr_data_list.size(), Botan::ASN1_Type::Integer )
                   .end_cons(); // data push
            }
 
            Botan::PK_Signer signer(*sign_sec_key, rng, crypto_cfg.pk_sign_algo);
            signer.update(header_buffer);
            out_bytes_header += header_buffer.size();
            if( listener->getSendContent( decrypt_mode ) ) {
                listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::header, header_buffer, false /* final */);
            }
            jau_DBG_PRINT("Encrypt: DER Header1 written + %zu bytes / %" PRIu64 " bytes", header_buffer.size(), out_bytes_header);
 
            for(const recevr_data_t& recevr_data : recevr_data_list) {
                // DER Header recevr_n
                header_buffer.clear();
                {
                    Botan::DER_Encoder der(header_buffer);
                    der.start_sequence()
                       .encode( recevr_data.fingerprint, Botan::ASN1_Type::OctetString )
                       .encode( recevr_data.encrypted_sym_key, Botan::ASN1_Type::OctetString )
                       .encode( recevr_data.encrypted_nonce, Botan::ASN1_Type::OctetString )
                       .end_cons();
                }
                signer.update(header_buffer);
                out_bytes_header += header_buffer.size();
                if( listener->getSendContent( decrypt_mode ) ) {
                    listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::header, header_buffer, false /* final */);
                }
                jau_DBG_PRINT("Encrypt: DER Header-recevr written + %zu bytes / %" PRIu64 " bytes", header_buffer.size(), out_bytes_header);
            }
 
            // DER-Header-2 (signature)
            sender_signature = signer.signature(rng);
            jau_DBG_PRINT("Encrypt: Signature for %" PRIu64 " bytes: %s", out_bytes_header,
                    jau::toHexString(sender_signature, jau::lb_endian_t::little));
            header_buffer.clear();
            {
                Botan::DER_Encoder der(header_buffer);
                der.start_sequence()
                   .encode( sender_signature, Botan::ASN1_Type::OctetString )
                   .end_cons();
            }
            out_bytes_header += header_buffer.size();
            if( listener->getSendContent( decrypt_mode ) ) {
                listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::header, header_buffer, false /* final */);
            }
            jau_DBG_PRINT("Encrypt: DER Header2 written + %zu bytes / %" PRIu64 " bytes for %zu keys", header_buffer.size(), out_bytes_header, recevr_data_list.size());
        }
 
        header = PackHeader(target_path,
                            plaintext_size,
                            ts_creation,
                            subject,
                            plaintext_version, plaintext_version_parent,
                            crypto_cfg,
                            sender_fingerprint,
                            recevr_fingerprints,
                            -1 /* term_key_fingerprint_used_idx */,
                            false /* valid */);
 
        jau_DBG_PRINT("Encrypt: DER Header done, %" PRIu64 " header: %s",
                out_bytes_header, header.to_string(true /* show_crypto_algos */, true /* force_all_fingerprints */));
 
        if( !listener->notifyHeader(decrypt_mode, header) ) {
            jau_DBG_PRINT("Encrypt: notifyHeader() user abort from %s", source.toString());
            return header;
        }
 
        //
        // Symmetric Encryption incl. hash
        //
 
        aead->set_key(plain_sym_key);
        aead->set_associated_data_vec(sender_signature);
        aead->start(nonce);
 
        const bool sent_content_to_user = listener->getSendContent( decrypt_mode );
        uint64_t out_bytes_ciphertext = 0;
        bool consume_abort = false;
        _StreamConsumerFunc consume_data = [&](cipherpack::secure_vector<uint8_t>& data, bool is_final) -> bool {
            bool res = true;
            // A simple !is_final suffices, since a final call w/ zero bytes shall add a TAG or padding depending on AEAD.
            if( !is_final ) {
                if( nullptr != plaintext_hash_func ) {
                    plaintext_hash_func->update(data);
                }
                aead->update(data);
                if( sent_content_to_user ) {
                    res = listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::message, data, false /* is_final */);
                }
                out_bytes_ciphertext += data.size();
                if( res ) {
                    res = listener->notifyProgress(decrypt_mode, plaintext_size, source.position());
                }
                jau_DBG_PRINT("Encrypt: EncPayload written0 + %zu bytes -> %" PRIu64 " bytes / %zu bytes, user[sent %d, res %d]",
                        data.size(), out_bytes_ciphertext, plaintext_size, sent_content_to_user, res);
            } else {
                if( nullptr != plaintext_hash_func ) {
                    plaintext_hash_func->update(data);
                }
                aead->finish(data);
                if( sent_content_to_user ) {
                    res = listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::message, data, true /* is_final */);
                }
                out_bytes_ciphertext += data.size();
                if( !has_plaintext_size ) {
                    plaintext_size = out_bytes_ciphertext;
                    header.set_plaintext_size(plaintext_size);
                }
                if( res ) {
                    res = listener->notifyProgress(decrypt_mode, plaintext_size, source.position());
                }
                jau_DBG_PRINT("Encrypt: EncPayload writtenF + %zu bytes -> %" PRIu64 " bytes / %zu bytes, user[sent %d, res %d]",
                        data.size(), out_bytes_ciphertext, plaintext_size, sent_content_to_user, res);
            }
            consume_abort = !res;
            return res;
        };
        // No need for double-buffering here
        // as long at least one (last) consume_data is_final=true is being made (even w/ zero file size).
        // Note: The double-buffer variant works as well, manually tested.
        cipherpack::secure_vector<uint8_t> io_buffer;
        io_buffer.reserve(Constants::buffer_size);
        const uint64_t in_bytes_total = _read_stream(source, io_buffer, consume_data);
        source.close();
 
        if( nullptr != plaintext_hash_func ) {
            std::vector<uint8_t> hash_value( plaintext_hash_func->output_length() );
            plaintext_hash_func->final(hash_value.data());
            header.set_plaintext_hash(plaintext_hash_func->name(), hash_value);
        }
 
        if( consume_abort ) {
            jau_DBG_PRINT("Encrypt: Processing aborted %s", source.toString());
            return header;
        }
        if ( source.fail() ) {
            listener->notifyError(decrypt_mode, header, "Source read failed "+source.toString());
            return header;
        }
        if( source.position() != in_bytes_total ) {
            listener->notifyError(decrypt_mode, header, "Writing done, "+jau::to_decstring(in_bytes_total)+" bytes read != "+source.toString());
            return header;
        } else if( jau::environment::get().verbose ) {
            jau_WORDY_PRINT("Encrypt: Reading done from %s", source.toString());
            jau_WORDY_PRINT("Encrypt: Writing done, %s header + %s ciphertext for %s plaintext bytes written, ratio %f out/in",
                    jau::to_decstring(out_bytes_header),
                    jau::to_decstring(out_bytes_ciphertext),
                    jau::to_decstring(in_bytes_total), in_bytes_total > 0 ? (double)(out_bytes_header+out_bytes_ciphertext)/(double)in_bytes_total : 0.0);
            jau_WORDY_PRINT("Encrypt: Writing done: source: %s", source.toString());
        }
 
        if( jau::environment::get().verbose ) {
            const jau::fraction_i64 _td = ( jau::getMonotonicTime() - _t0 ).to_fraction_i64();
            jau::io::print_stats("Encrypt", (out_bytes_header+out_bytes_ciphertext), _td);
        }
        header.setValid(true);
        return header;
    } catch (std::exception &e) {
        jau_ERR_PRINT("Encrypt failed: Caught exception: %s on %s", e.what(), source.toString());
        return header;
    }
}
 
PackHeader cipherpack::encryptThenSign(const CryptoConfig& crypto_cfg,
                                       const std::vector<std::string>& enc_pub_keys,
                                       const std::string& sign_sec_key_fname, const jau::io::secure_string& passphrase,
                                       jau::io::ByteStream& source,
                                       const std::string& target_path, const std::string& subject,
                                       const std::string& plaintext_version,
                                       const std::string& plaintext_version_parent,
                                       CipherpackListenerRef listener, // NOLINT(performance-unnecessary-value-param)
                                       const std::string_view& plaintext_hash_algo,
                                       const std::string dest_fname) { // NOLINT(performance-unnecessary-value-param)
    environment::get();
    const bool decrypt_mode = false;
 
    if( dest_fname.empty() ) {
        PackHeader header = encryptThenSign_Impl(crypto_cfg,
                                             enc_pub_keys,
                                             sign_sec_key_fname, passphrase,
                                             source,
                                             target_path, subject,
                                             plaintext_version,
                                             plaintext_version_parent,
                                             listener, plaintext_hash_algo);
        if( header.isValid() ) {
            listener->notifyEnd(decrypt_mode, header);
        }
        return header;
    }
    std::string dest_fname2;
    if( dest_fname == "/dev/stdout" || dest_fname == "-" ) {
        dest_fname2 = "/dev/stdout";
    } else {
        dest_fname2 = dest_fname;
    }
 
    const jau::fraction_timespec ts_creation = jau::getWallClockTime();
 
    PackHeader header(target_path,
                      source.contentSize(),
                      ts_creation,
                      subject,
                      plaintext_version, plaintext_version_parent,
                      crypto_cfg,
                      std::vector<uint8_t>(),
                      std::vector<std::vector<uint8_t>>(),
                      -1 /* term_key_fingerprint_used_idx */,
                      false /* valid */);
 
    if( nullptr == listener ) {
        jau_ERR_PRINT2("Encrypt failed: Listener is nullptr for source %s", source.toString());
        return header;
    }
 
    class MyListener : public WrappingCipherpackListener {
        private:
            jau::io::ByteStream_File* outfile_;
            uint64_t& out_bytes_header_;
            uint64_t& out_bytes_plaintext_;
        public:
            MyListener(CipherpackListenerRef parent_, uint64_t& bytes_header, uint64_t& bytes_plaintext)
            : WrappingCipherpackListener( parent_ ), outfile_(nullptr),                                    // NOLINT(performance-unnecessary-value-param)
              out_bytes_header_(bytes_header), out_bytes_plaintext_(bytes_plaintext)
            {}
 
            void set_outfile(jau::io::ByteStream_File* of) noexcept { outfile_ = of; }
 
            bool getSendContent(const bool /*decrypt_mode*/) const noexcept override {
                return true;
            }
 
            bool contentProcessed(const bool decrypt_mode, const content_type ctype, cipherpack::secure_vector<uint8_t>& data, const bool is_final) noexcept override {
                if( nullptr != outfile_ ) {
                    if( data.size() != outfile_->write(data.data(), data.size()) ) {
                        return false;
                    }
                    if( outfile_->fail() ) {
                        return false;
                    }
                    switch( ctype ) {
                        case content_type::header:
                            out_bytes_header_ += data.size();
                            break;
                        case content_type::message:
                            [[fallthrough]];
                        default:
                            out_bytes_plaintext_ += data.size();
                            break;
                    }
                }
                if( parent->getSendContent(decrypt_mode) ) {
                    return parent->contentProcessed(decrypt_mode, ctype, data, is_final);
                } else {
                    return true;
                }
            }
    };
    uint64_t out_bytes_header=0, out_bytes_plaintext=0;
    std::shared_ptr<MyListener> my_listener = std::make_shared<MyListener>(listener, out_bytes_header, out_bytes_plaintext);
    {
        const jau::io::fs::file_stats output_stats(dest_fname2);
        if( output_stats.exists() && !output_stats.has_fd() ) {
            if( output_stats.is_file() ) {
                if( !jau::io::fs::remove(dest_fname2) ) {
                    listener->notifyError(decrypt_mode, header, "Failed deletion of existing output file "+output_stats.toString());
                    return header;
                }
            } else if( output_stats.is_dir() || output_stats.is_block() ) {
                listener->notifyError(decrypt_mode, header, "Not overwriting existing "+output_stats.toString());
                return header;
            }
        }
    }
    jau::io::ByteStream_File outfile(dest_fname2);
    if ( !outfile.good() ) {
        listener->notifyError(decrypt_mode, header, "Output file not open "+dest_fname2);
        return header;
    }
    my_listener->set_outfile(&outfile);
 
    header = encryptThenSign_Impl(crypto_cfg,
                                  enc_pub_keys,
                                  sign_sec_key_fname, passphrase,
                                  source,
                                  target_path, subject,
                                  plaintext_version,
                                  plaintext_version_parent,
                                  my_listener, plaintext_hash_algo);
    {
        const jau::io::fs::file_stats output_stats(dest_fname2);
        if ( outfile.fail() ) {
            if( output_stats.is_file() && !output_stats.has_fd() ) {
                jau::io::fs::remove(dest_fname2);
            }
            header.setValid(false);
            listener->notifyError(decrypt_mode, header, "Output file write failed "+dest_fname2);
            return header;
        }
        outfile.close();
 
        if( !header.isValid() ) {
            if( output_stats.is_file() && !output_stats.has_fd() ) {
                jau::io::fs::remove(dest_fname2);
            }
            return header;
        }
    }
    // outfile closed
    const jau::io::fs::file_stats output_stats(dest_fname2);
    // TODO: Perhaps figure out 'ciphertext_size_same' for all streamcipher. true for `ChaCha20Poly1305`
    constexpr const bool ciphertext_size_same = false;
    if constexpr ( ciphertext_size_same ) {
        // Test is only valid, IFF out_bytes_plaintext == out_bytes_ciphertext
        if( output_stats.is_file() && out_bytes_header + out_bytes_plaintext != output_stats.size() ) {
            if( output_stats.is_file() && !output_stats.has_fd() ) {
                jau::io::fs::remove(dest_fname2);
            }
            header.setValid(false);
            listener->notifyError(decrypt_mode, header,
                    "Writing done, "+jau::to_decstring(out_bytes_header)+" header + "+jau::to_decstring(out_bytes_plaintext)+
                    " plaintext != "+jau::to_decstring(output_stats.size())+" total bytes");
            return header;
        }
    }
    jau_WORDY_PRINT("Encrypt: Writing done: output: %s", output_stats.toString());
 
    my_listener->notifyEnd(decrypt_mode, header);
    return header;
}
 
 
static PackHeader checkSignThenDecrypt_Impl(const std::vector<std::string>& sign_pub_keys,
                                            const std::string& dec_sec_key_fname, const jau::io::secure_string& passphrase,
                                            jau::io::ByteStream& source,
                                            CipherpackListenerRef listener,
                                            const std::string_view& plaintext_hash_algo) {
    const bool decrypt_mode = true;
    environment::get();
    jau::fraction_timespec ts_creation;
    PackHeader header(ts_creation);
 
    if( nullptr == listener ) {
        jau_ERR_PRINT2("Decrypt failed: Listener is nullptr for source %s", source.toString());
        return header;
    }
 
    const jau::fraction_timespec _t0 = jau::getMonotonicTime();
 
    if( !source.good() ) {
        listener->notifyError(decrypt_mode, header, "Source is EOS or has an error "+source.toString());
        return header;
    }
    try {
        Botan::RandomNumberGenerator& rng = Botan::system_rng();
 
        std::unique_ptr<Botan::HashFunction> fingerprint_hash_func;
        struct sender_data_t {
            std::shared_ptr<Botan::Public_Key> pub_key;
            std::vector<uint8_t> fingerprint;
        };
        std::vector<sender_data_t> sender_data_list;
        for( const std::string& pub_key_fname : sign_pub_keys ) {
            sender_data_t sender_data;
            sender_data.pub_key = load_public_key(pub_key_fname);
            if( !sender_data.pub_key ) {
                listener->notifyError(decrypt_mode, header, "Loading pub-key file '"+pub_key_fname+"' failed");
                return header;
            }
            sender_data_list.push_back(sender_data);
        }
        std::shared_ptr<Botan::Public_Key> sender_pub_key = nullptr; // not found
 
        std::vector<std::vector<uint8_t>> recevr_fingerprints;
        std::shared_ptr<Botan::Private_Key> dec_sec_key = load_private_key(dec_sec_key_fname, passphrase);
        if( !dec_sec_key ) {
            listener->notifyError(decrypt_mode, header, "Loading priv-key file '"+dec_sec_key_fname+"' failed");
            return header;
        }
 
        std::string package_magic_in;
        std::string target_path;
        std::string subject;
        bool has_plaintext_size;
        uint64_t plaintext_size;
        std::string plaintext_version;
        std::string plaintext_version_parent;
 
        CryptoConfig crypto_cfg;
        Botan::OID sym_enc_algo_oid;
 
        std::vector<uint8_t> fingerprt_sender;
        ssize_t recevr_count;
        ssize_t used_recevr_key_idx = -1;
        std::vector<uint8_t> encrypted_sym_key;
        std::vector<uint8_t> encrypted_nonce;
 
        std::vector<uint8_t> sender_signature;
 
        std::unique_ptr<Botan::HashFunction> hash_func = nullptr;
        if( !plaintext_hash_algo.empty() ) {
            const std::string plaintext_hash_algo_s(plaintext_hash_algo);
            hash_func = Botan::HashFunction::create(plaintext_hash_algo_s);
            if( nullptr == hash_func ) {
                listener->notifyError(decrypt_mode, header, "Payload hash algo '"+plaintext_hash_algo_s+"' not available");
                return header;
            }
        }
 
        jau::io::secure_vector<uint8_t> input_buffer;
        jau::io::ByteStream_Recorder input(source, input_buffer);
        WrappingDataSource winput(input);
        uint64_t in_bytes_header = 0;
 
        try {
            // DER-Header-1
            input.startRecording();
            {
                std::vector<uint8_t> package_magic_charvec;
 
                Botan::BER_Decoder ber0(winput);
 
                Botan::BER_Decoder ber = ber0.start_sequence();
                ber.decode(package_magic_charvec, Botan::ASN1_Type::OctetString);
                package_magic_in = to_string(package_magic_charvec);
 
                if( Constants::package_magic != package_magic_in ) {
                    listener->notifyError(decrypt_mode, header,
                            "Expected Magic '"+Constants::package_magic+"', but got '"+package_magic_in+
                            "' in "+source.toString());
                    return header;
                }
                jau_DBG_PRINT("Decrypt: Magic is %s", package_magic_in);
 
                std::vector<uint8_t> target_path_charvec;
                Botan::BigInt bi_plaintext_size;
                Botan::BigInt bi_ts_creation_sec;
                Botan::BigInt bi_ts_creation_nsec;
                std::vector<uint8_t> subject_charvec;
                std::vector<uint8_t> plaintext_version_charvec;
                std::vector<uint8_t> plaintext_version_parent_charvec;
 
                std::vector<uint8_t> pk_type_cv;
                std::vector<uint8_t> pk_fingerprt_hash_algo_cv;
                std::vector<uint8_t> pk_enc_padding_algo_cv;
                std::vector<uint8_t> pk_enc_hash_algo_cv;
                std::vector<uint8_t> pk_sign_algo_cv;
                Botan::BigInt bi_recevr_count;
 
                ber.decode( target_path_charvec, Botan::ASN1_Type::OctetString )
                   .decode( bi_plaintext_size, Botan::ASN1_Type::Integer )
                   .decode( bi_ts_creation_sec, Botan::ASN1_Type::Integer )
                   .decode( bi_ts_creation_nsec, Botan::ASN1_Type::Integer )
                   .decode( subject_charvec, Botan::ASN1_Type::OctetString )
                   .decode( plaintext_version_charvec, Botan::ASN1_Type::OctetString )
                   .decode( plaintext_version_parent_charvec, Botan::ASN1_Type::OctetString )
                   .decode( pk_type_cv, Botan::ASN1_Type::OctetString )
                   .decode( pk_fingerprt_hash_algo_cv, Botan::ASN1_Type::OctetString )
                   .decode( pk_enc_padding_algo_cv, Botan::ASN1_Type::OctetString )
                   .decode( pk_enc_hash_algo_cv, Botan::ASN1_Type::OctetString )
                   .decode( pk_sign_algo_cv, Botan::ASN1_Type::OctetString )
                   .decode( sym_enc_algo_oid )
                   .decode( fingerprt_sender, Botan::ASN1_Type::OctetString )
                   .decode( bi_recevr_count, Botan::ASN1_Type::Integer )
                   .end_cons()
                   ;
 
                target_path = to_string(target_path_charvec);
                subject = to_string(subject_charvec);
                plaintext_size = to_uint64_t(bi_plaintext_size);
                has_plaintext_size = 0 < plaintext_size;
                ts_creation.tv_sec = static_cast<int64_t>( to_uint64_t(bi_ts_creation_sec) );
                ts_creation.tv_nsec = static_cast<int64_t>( to_uint64_t(bi_ts_creation_nsec) );
                plaintext_version = to_string(plaintext_version_charvec);
                plaintext_version_parent = to_string(plaintext_version_parent_charvec);
                crypto_cfg.pk_type = to_string( pk_type_cv );
                crypto_cfg.pk_fingerprt_hash_algo = to_string( pk_fingerprt_hash_algo_cv );
                crypto_cfg.pk_enc_padding_algo = to_string( pk_enc_padding_algo_cv );
                crypto_cfg.pk_enc_hash_algo = to_string( pk_enc_hash_algo_cv );
                crypto_cfg.pk_sign_algo = to_string( pk_sign_algo_cv );
                crypto_cfg.sym_enc_algo = Botan::OIDS::oid2str_or_empty( sym_enc_algo_oid );
                recevr_count = to_positive_int64_t(bi_recevr_count);
            }
 
            header = PackHeader(target_path,
                                plaintext_size,
                                ts_creation,
                                subject,
                                plaintext_version, plaintext_version_parent,
                                crypto_cfg,
                                fingerprt_sender,
                                recevr_fingerprints,
                                used_recevr_key_idx,
                                false /* valid */);
 
            if( fingerprt_sender.empty() ) {
                listener->notifyError(decrypt_mode, header, "Fingerprint sender is empty");
                return header;
            }
            fingerprint_hash_func = Botan::HashFunction::create(crypto_cfg.pk_fingerprt_hash_algo);
            if( nullptr == fingerprint_hash_func ) {
                listener->notifyError(decrypt_mode, header,
                        "Fingerprint hash algo '"+crypto_cfg.pk_fingerprt_hash_algo+"' not available");
                return header;
            }
 
            for( sender_data_t& sender_data : sender_data_list ) {
                if( sender_data.pub_key->algo_name() == crypto_cfg.pk_type ) {
                    sender_data.fingerprint = _fingerprint_public( *sender_data.pub_key, *fingerprint_hash_func );
                    if( fingerprt_sender == sender_data.fingerprint ) {
                            sender_pub_key = sender_data.pub_key;
                            break;
                    }
                }
            }
            if( nullptr == sender_pub_key ) {
                listener->notifyError(decrypt_mode, header,
                        "No matching sender fingerprint, received '"+jau::toHexString(fingerprt_sender, jau::lb_endian_t::little)+
                        "` in "+source.toString());
                return header;
            }
 
            Botan::PK_Verifier verifier(*sender_pub_key, crypto_cfg.pk_sign_algo);
            verifier.update( input.get_recording() );
            in_bytes_header += input.get_recording().size();
            input.startRecording(); // start over ..
 
            const std::vector<uint8_t> dec_key_fingerprint = _fingerprint_public( *dec_sec_key, *fingerprint_hash_func );
            std::vector<uint8_t> receiver_fingerprint_temp;
            std::vector<uint8_t> encrypted_sym_key_temp;
            std::vector<uint8_t> encrypted_nonce_temp;
 
            // DER-Header per receiver
            for(ssize_t idx=0; idx < recevr_count; idx++) {
                Botan::BER_Decoder ber(winput);
                ber.start_sequence()
                   .decode(receiver_fingerprint_temp, Botan::ASN1_Type::OctetString)
                   .decode(encrypted_sym_key_temp, Botan::ASN1_Type::OctetString)
                   .decode(encrypted_nonce_temp, Botan::ASN1_Type::OctetString)
                   .end_cons()
                   ;
                verifier.update( input.get_recording() );
                in_bytes_header += input.get_recording().size();
                input.startRecording(); // start over ..
 
                recevr_fingerprints.push_back(receiver_fingerprint_temp);
 
                if( 0 > used_recevr_key_idx  ) {
                    if( !receiver_fingerprint_temp.empty() && receiver_fingerprint_temp == dec_key_fingerprint ) {
                        // match, we found our entry
                        used_recevr_key_idx = idx;
                        encrypted_sym_key = encrypted_sym_key_temp; // pick the encrypted key
                        encrypted_nonce = encrypted_nonce_temp;     // and encrypted nonce
                    }
                }
            }
            header = PackHeader(target_path,
                                plaintext_size,
                                ts_creation,
                                subject,
                                plaintext_version, plaintext_version_parent,
                                crypto_cfg,
                                fingerprt_sender,
                                recevr_fingerprints,
                                used_recevr_key_idx,
                                false /* valid */);
 
            if( 0 > used_recevr_key_idx || 0 == recevr_count ) {
                listener->notifyError(decrypt_mode, header,
                        "No matching receiver key found "+std::to_string(used_recevr_key_idx)+"/"+std::to_string(recevr_count)+
                        " in "+source.toString());
                return header;
            }
 
            const uint64_t in_bytes_signature = in_bytes_header;
            {
                Botan::BER_Decoder ber(winput);
                ber.start_sequence()
                   .decode(sender_signature, Botan::ASN1_Type::OctetString)
                   .end_cons() // encrypted data follows ..
                   ;
                in_bytes_header += input.get_recording().size();
                input.clearRecording(); // implies stop
            }
            if( !verifier.check_signature(sender_signature) ) {
                listener->notifyError(decrypt_mode, header,
                        "Signature mismatch on "+std::to_string(in_bytes_signature)+" header bytes / "+std::to_string(in_bytes_header)+
                        " bytes, received signature '"+jau::toHexString(sender_signature, jau::lb_endian_t::little)+
                        "' in "+source.toString() );
                return header;
            }
 
            jau_DBG_PRINT("Decrypt: Signature OK for %" PRIu64 " header bytes / %" PRIu64 ": %s from %s",
                    in_bytes_signature, in_bytes_header,
                    jau::toHexString(sender_signature, jau::lb_endian_t::little),
                    source.toString());
 
            jau_DBG_PRINT("Decrypt: DER Header*: enc_key %zu/%zu (size %zu): %s",
                    used_recevr_key_idx, recevr_count, encrypted_sym_key.size(),
                    header.to_string(true /* show_crypto_algos */, true /* force_all_fingerprints */));
        } catch (Botan::Decoding_Error &e) {
            listener->notifyError(decrypt_mode, header, "Header Decoding: "+std::string(e.what())+" on "+input.toString()+" -> "+source.toString());
            return header;
        }
        jau_DBG_PRINT("Decrypt: target_path '%s', net_file_size %s, version %s (parent %s), subject %s",
                target_path, jau::to_decstring(plaintext_size),
                plaintext_version,
                plaintext_version_parent,
                subject);
        jau_DBG_PRINT("Decrypt: creation time %s UTC", ts_creation.toISO8601String());
 
        if( !listener->notifyHeader(decrypt_mode, header) ) {
            jau_DBG_PRINT("Decrypt: notifyHeader() user abort from %s", source.toString());
            return header;
        }
 
        //
        // Symmetric Encryption
        //
 
        std::shared_ptr<Botan::AEAD_Mode> aead = Botan::AEAD_Mode::create_or_throw(crypto_cfg.sym_enc_algo, Botan::DECRYPTION);
        if(!aead) {
           listener->notifyError(decrypt_mode, header, "sym_enc_algo '"+crypto_cfg.sym_enc_algo+"' not available from '"+source.toString()+"'");
           return header;
        }
        const size_t expected_keylen = aead->key_spec().maximum_keylength();
 
        Botan::PK_Decryptor_EME dec(*dec_sec_key, rng, crypto_cfg.pk_enc_padding_algo+"(" + crypto_cfg.pk_enc_hash_algo + ")");
 
        const cipherpack::secure_vector<uint8_t> plain_file_key =
                dec.decrypt_or_random(encrypted_sym_key.data(), encrypted_sym_key.size(), expected_keylen, rng);
        const cipherpack::secure_vector<uint8_t> nonce = dec.decrypt(encrypted_nonce);
        crypto_cfg.sym_enc_nonce_bytes = nonce.size();
        header = PackHeader(target_path,
                            plaintext_size,
                            ts_creation,
                            subject,
                            plaintext_version, plaintext_version_parent,
                            crypto_cfg,
                            fingerprt_sender,
                            recevr_fingerprints,
                            used_recevr_key_idx,
                            false /* valid */);
        jau_DBG_PRINT("Decrypt sym_key[sz %zu], %s", plain_file_key.size(), crypto_cfg.to_string());
 
        if( !crypto_cfg.valid() ) {
            listener->notifyError(decrypt_mode, header, "CryptoConfig incomplete "+crypto_cfg.to_string()+" from "+source.toString());
            return header;
        }
 
        aead->set_key(plain_file_key);
        aead->set_associated_data_vec(sender_signature);
        aead->start(nonce);
 
        const bool sent_content_to_user = listener->getSendContent( decrypt_mode );
        uint64_t out_bytes_plaintext = 0;
        bool consume_abort = false;
        _StreamConsumerFunc consume_data = [&](cipherpack::secure_vector<uint8_t>& data, bool is_final) -> bool {
            bool res = true;
            const uint64_t next_total = out_bytes_plaintext + data.size();
            const size_t minimum_final_size = aead->minimum_final_size();
#if 0
            const size_t update_granularity = aead->update_granularity();
            jau_DBG_PRINT("Decrypt: update_gran %zu, min_fin_sz %zu, is_final %d, has_plaintext_size %d,  %" PRIu64 " + %zu = %" PRIu64 " <=  %" PRIu64 " = %d",
                    update_granularity, minimum_final_size,
                    is_final, has_plaintext_size,
                    out_bytes_plaintext, data.size(), next_total, plaintext_size, next_total <= plaintext_size);
#endif
            // 'next_total <= plaintext_size' included plaintext_size limit since at least one AEAD TAG will be added afterwards (or padding)
            if( !is_final && ( !has_plaintext_size || ( 0 < minimum_final_size && next_total <= plaintext_size ) || next_total < plaintext_size ) ) {
                try {
                    aead->update(data);
                } catch (std::exception &e) {
                    consume_abort = true;
                    listener->notifyError(decrypt_mode, header, "Decrypting (.): "+std::string(e.what())+
                                          " @ plaintext ( "+std::to_string(out_bytes_plaintext)+" + "+std::to_string(data.size())+" ) / "+std::to_string(plaintext_size)+
                                          " bytes, final "+std::to_string(is_final)+" on "+source.toString());
                    return false;
                }
                if( nullptr != hash_func ) {
                    hash_func->update(data);
                }
                if( sent_content_to_user ) {
                    res = listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::message, data, false /* is_final */);
                }
                out_bytes_plaintext += data.size();
                if( res ) {
                    res = listener->notifyProgress(decrypt_mode, plaintext_size, out_bytes_plaintext);
                }
                jau_DBG_PRINT("Decrypt: DecPayload written0 + %zu bytes -> %" PRIu64 " bytes / %zu bytes, user[sent %d, res %d]",
                        data.size(), out_bytes_plaintext, plaintext_size, sent_content_to_user, res);
                consume_abort = !res;
                return res; // continue if user so desires
            } else {
                try {
                    aead->finish(data);
                } catch (std::exception &e) {
                    consume_abort = true;
                    listener->notifyError(decrypt_mode, header, "Decrypting (F): "+std::string(e.what())+
                                          " @ plaintext ( "+std::to_string(out_bytes_plaintext)+" + "+std::to_string(data.size())+" ) / "+std::to_string(plaintext_size)+
                                          " bytes, final "+std::to_string(is_final)+" on "+source.toString());
                    return false;
                }
                if( nullptr != hash_func ) {
                    hash_func->update(data);
                }
                if( sent_content_to_user ) {
                    res = listener->contentProcessed(decrypt_mode, CipherpackListener::content_type::message, data, true /* is_final */);
                }
                out_bytes_plaintext += data.size();
                if( !has_plaintext_size ) {
                    plaintext_size = out_bytes_plaintext;
                    header.set_plaintext_size(plaintext_size);
                }
                if( res ) {
                    res = listener->notifyProgress(decrypt_mode, plaintext_size, out_bytes_plaintext);
                }
                jau_DBG_PRINT("Decrypt: DecPayload writtenF + %zu bytes -> %" PRIu64 " bytes / %zu bytes, user[sent %d, res %d]",
                        data.size(), out_bytes_plaintext, plaintext_size, sent_content_to_user, res);
                consume_abort = !res;
                return false; // EOS
            }
        };
        // Note: Utilizing the double-buffered read-ahead read_stream() ensures `is_final` (i.e. eof)
        // is delivered with the last concume_data() call and data.size() > 0.
        //
        // This avoids decryption errors using manual-feeding or a file pipe w/o content-size known.
        //
        cipherpack::secure_vector<uint8_t> io_buffer1;
        cipherpack::secure_vector<uint8_t> io_buffer2;
        io_buffer1.reserve(Constants::buffer_size);
        io_buffer2.reserve(Constants::buffer_size);
        const uint64_t in_bytes_total = _read_stream(input, io_buffer1, io_buffer2, consume_data);
        input.close();
 
        if( nullptr != hash_func ) {
            std::vector<uint8_t> hash_value( hash_func->output_length() );
            hash_func->final(hash_value.data());
            header.set_plaintext_hash(hash_func->name(), hash_value);
        }
        if( consume_abort ) {
            jau_DBG_PRINT("Decrypt: Processing aborted %s", source.toString());
            return header;
        }
        if ( source.fail() ) {
            listener->notifyError(decrypt_mode, header, "Reading stream failed "+source.toString());
            return header;
        }
        if( 0==in_bytes_total ) {
            listener->notifyError(decrypt_mode, header, "Processing stream failed "+source.toString());
            return header;
        }
        if( out_bytes_plaintext != plaintext_size ) {
            listener->notifyError(decrypt_mode, header, "Plaintext size mismatch: "+
                    jau::to_decstring(out_bytes_plaintext)+" output bytes != "+
                    jau::to_decstring(plaintext_size)+" header plaintext bytes from "+
                    source.toString());
            return header;
        } else {
            jau_WORDY_PRINT("Decrypt: Reading done from %s", source.toString());
            jau_WORDY_PRINT("Decrypt: Writing done, %s plaintext bytes from %s ciphertext bytes input, ratio %f in/out",
                    jau::to_decstring(out_bytes_plaintext),
                    jau::to_decstring(in_bytes_total),
                    in_bytes_total > 0 ? (double)out_bytes_plaintext/(double)in_bytes_total : 0.0);
        }
 
        const jau::fraction_i64 _td = ( jau::getMonotonicTime() - _t0 ).to_fraction_i64();
        if( jau::environment::get().verbose ) {
            jau::io::print_stats("Decrypt", out_bytes_plaintext, _td);
        }
 
        header.setValid(true);
        return header;
    } catch (std::exception &e) {
        listener->notifyError(decrypt_mode, header, "Exception: "+std::string(e.what())+" on "+source.toString());
        return header;
    }
}
 
PackHeader cipherpack::checkSignThenDecrypt(const std::vector<std::string>& sign_pub_keys,
                                            const std::string& dec_sec_key_fname, const jau::io::secure_string& passphrase,
                                            jau::io::ByteStream& source,
                                            CipherpackListenerRef listener, // NOLINT(performance-unnecessary-value-param)
                                            const std::string_view& plaintext_hash_algo,
                                            const std::string dest_fname) { // NOLINT(performance-unnecessary-value-param)
    environment::get();
    const bool decrypt_mode = true;
 
    if( dest_fname.empty() ) {
        PackHeader header = checkSignThenDecrypt_Impl(sign_pub_keys,
                                                  dec_sec_key_fname, passphrase,
                                                  source, listener, plaintext_hash_algo);
        if( header.isValid() ) {
            listener->notifyEnd(decrypt_mode, header);
        }
        return header;
    }
    std::string dest_fname2;
    if( dest_fname == "/dev/stdout" || dest_fname == "-" ) {
        dest_fname2 = "/dev/stdout";
    } else {
        dest_fname2 = dest_fname;
    }
 
    jau::fraction_timespec ts_creation;
    PackHeader header(ts_creation);
 
    if( nullptr == listener ) {
        jau_ERR_PRINT2("Decrypt failed: Listener is nullptr for source %s", source.toString());
        return header;
    }
 
    class MyListener : public WrappingCipherpackListener {
        private:
            bool sent_content_to_user;
            jau::io::ByteStream_File* outfile_;
            uint64_t& out_bytes_plaintext_;
        public:
            MyListener(CipherpackListenerRef parent_, uint64_t& bytes_plaintext)   // NOLINT(performance-unnecessary-value-param)
            : WrappingCipherpackListener(parent_),
              sent_content_to_user(parent_->getSendContent( decrypt_mode )),
              outfile_(nullptr),
              out_bytes_plaintext_(bytes_plaintext)
            {}
 
            void set_outfile(jau::io::ByteStream_File* of) noexcept { outfile_ = of; }
 
            bool getSendContent(const bool /*decrypt_mode*/) const noexcept override {
                return true;
            }
 
            bool contentProcessed(const bool decrypt_mode, const content_type ctype, cipherpack::secure_vector<uint8_t>& data, const bool is_final) noexcept override {
                if( nullptr != outfile_ && content_type::message == ctype ) {
                    if( data.size() != outfile_->write(data.data(), data.size()) ) {
                        return false;
                    }
                    if( outfile_->fail() ) {
                        return false;
                    }
                    out_bytes_plaintext_ += data.size();
                }
                if( sent_content_to_user ) {
                    return parent->contentProcessed(decrypt_mode, ctype, data, is_final);
                } else {
                    return true;
                }
            }
    };
    uint64_t out_bytes_plaintext=0;
    std::shared_ptr<MyListener> my_listener = std::make_shared<MyListener>(listener, out_bytes_plaintext);
    {
        const jau::io::fs::file_stats output_stats(dest_fname2);
        if( output_stats.exists() && !output_stats.has_fd() ) {
            if( output_stats.is_file() ) {
                if( !jau::io::fs::remove(dest_fname2) ) {
                    my_listener->notifyError(decrypt_mode, header, "Failed deletion of existing output file "+output_stats.toString());
                    return header;
                }
            } else if( output_stats.is_dir() || output_stats.is_block() ) {
                my_listener->notifyError(decrypt_mode, header, "Not overwriting existing "+output_stats.toString());
                return header;
            }
        }
    }
    jau::io::ByteStream_File outfile(dest_fname2);
    if ( !outfile.good() ) {
        my_listener->notifyError(decrypt_mode, header, "Failed to open output file "+outfile.toString());
        return header;
    }
    my_listener->set_outfile(&outfile);
 
    header = checkSignThenDecrypt_Impl(sign_pub_keys,
                                       dec_sec_key_fname, passphrase,
                                       source, my_listener, plaintext_hash_algo);
 
    {
        const jau::io::fs::file_stats output_stats(dest_fname2);
        if ( outfile.fail() ) {
            if( output_stats.is_file() && !output_stats.has_fd() ) {
                jau::io::fs::remove(dest_fname2);
            }
            header.setValid(false);
            my_listener->notifyError(decrypt_mode, header, "Failed to write output file "+dest_fname2);
            return header;
        }
        outfile.close();
 
        if( !header.isValid() ) {
            if( output_stats.is_file() && !output_stats.has_fd() ) {
                jau::io::fs::remove(dest_fname2);
            }
            return header;
        }
    }
    // outfile closed
    const jau::io::fs::file_stats output_stats(dest_fname2);
    if( output_stats.is_file() && header.plaintext_size() != output_stats.size() ) {
        if( output_stats.is_file() && !output_stats.has_fd() ) {
            jau::io::fs::remove(dest_fname2);
        }
        header.setValid(false);
        listener->notifyError(decrypt_mode, header, "Output plaintext file size mismatch: "+
                jau::to_decstring(output_stats.size())+" output file bytes != "+
                jau::to_decstring(header.plaintext_size())+" header plaintext bytes from "+
                source.toString());
        return header;
    }
 
    jau_WORDY_PRINT("Decrypt: Writing done: output: %s", output_stats.toString());
    my_listener->notifyEnd(decrypt_mode, header);
    return header;
}