9#ifndef BOTAN_FILTERS_H_
10#define BOTAN_FILTERS_H_
12#include <botan/cipher_mode.h>
13#include <botan/data_snk.h>
14#include <botan/pipe.h>
15#include <botan/secmem.h>
16#include <botan/symkey.h>
18#if defined(BOTAN_TARGET_OS_HAS_THREADS)
22#if defined(BOTAN_HAS_STREAM_CIPHER)
23 #include <botan/stream_cipher.h>
26#if defined(BOTAN_HAS_HASH)
27 #include <botan/hash.h>
30#if defined(BOTAN_HAS_MAC)
31 #include <botan/mac.h>
48 void write(
const uint8_t in[],
size_t length);
50 template <
typename Alloc>
51 void write(
const std::vector<uint8_t, Alloc>& in,
size_t length) {
52 write(in.data(), length);
106 size_t m_main_block_mod, m_final_minimum;
171 bool valid_iv_length(
size_t length)
const override;
173 std::string name()
const override;
176 void write(
const uint8_t input[],
size_t input_length)
override;
177 void start_msg()
override;
178 void end_msg()
override;
180 void buffered_block(
const uint8_t input[],
size_t input_length)
override;
181 void buffered_final(
const uint8_t input[],
size_t input_length)
override;
183 std::unique_ptr<Cipher_Mode> m_mode;
184 std::vector<uint8_t> m_nonce;
243#if defined(BOTAN_HAS_STREAM_CIPHER)
248class BOTAN_PUBLIC_API(2, 0) StreamCipher_Filter final :
public Keyed_Filter {
250 std::string name()
const override {
return m_cipher->name(); }
257 void write(
const uint8_t input[],
size_t input_len)
override;
259 bool valid_iv_length(
size_t iv_len)
const override {
return m_cipher->valid_iv_length(iv_len); }
265 void set_iv(
const InitializationVector& iv)
override { m_cipher->set_iv(iv.begin(), iv.length()); }
271 void set_key(
const SymmetricKey& key)
override { m_cipher->set_key(key); }
273 Key_Length_Specification key_spec()
const override {
return m_cipher->key_spec(); }
279 explicit StreamCipher_Filter(StreamCipher* cipher);
286 StreamCipher_Filter(StreamCipher* cipher,
const SymmetricKey& key);
292 explicit StreamCipher_Filter(std::string_view cipher);
299 StreamCipher_Filter(std::string_view cipher,
const SymmetricKey& key);
302 std::unique_ptr<StreamCipher> m_cipher;
303 secure_vector<uint8_t> m_buffer;
307#if defined(BOTAN_HAS_HASH)
314 void write(
const uint8_t input[],
size_t len)
override { m_hash->update(input, len); }
316 void end_msg()
override;
318 std::string name()
const override {
return m_hash->name(); }
328 BOTAN_FUTURE_EXPLICIT Hash_Filter(HashFunction* hash,
size_t len = 0) : m_hash(hash), m_out_len(len) {}
341 std::unique_ptr<HashFunction> m_hash;
342 const size_t m_out_len;
346#if defined(BOTAN_HAS_MAC)
353 void write(
const uint8_t input[],
size_t len)
override { m_mac->update(input, len); }
355 void end_msg()
override;
357 std::string name()
const override {
return m_mac->name(); }
363 void set_key(
const SymmetricKey& key)
override { m_mac->set_key(key); }
365 Key_Length_Specification key_spec()
const override {
return m_mac->key_spec(); }
376 m_mac(mac), m_out_len(out_len) {}
387 MAC_Filter(MessageAuthenticationCode* mac,
const SymmetricKey& key,
size_t out_len = 0) :
388 m_mac(mac), m_out_len(out_len) {
411 MAC_Filter(std::string_view mac,
const SymmetricKey& key,
size_t len = 0);
414 std::unique_ptr<MessageAuthenticationCode> m_mac;
415 const size_t m_out_len;
419#if defined(BOTAN_HAS_COMPRESSION)
429 void start_msg()
override;
430 void write(
const uint8_t input[],
size_t input_length)
override;
431 void end_msg()
override;
435 std::string name()
const override;
437 Compression_Filter(std::string_view type,
size_t compression_level,
size_t buffer_size = 4096);
439 ~Compression_Filter()
override;
441 Compression_Filter(
const Compression_Filter& other) =
delete;
442 Compression_Filter(Compression_Filter&& other) =
delete;
443 Compression_Filter& operator=(
const Compression_Filter& other) =
delete;
444 Compression_Filter& operator=(Compression_Filter&& other) =
delete;
447 std::unique_ptr<Compression_Algorithm> m_comp;
448 size_t m_buffersize, m_level;
449 secure_vector<uint8_t> m_buffer;
457 void start_msg()
override;
458 void write(
const uint8_t input[],
size_t input_length)
override;
459 void end_msg()
override;
461 std::string name()
const override;
465 ~Decompression_Filter()
override;
467 Decompression_Filter(
const Decompression_Filter& other) =
delete;
468 Decompression_Filter(Decompression_Filter&& other) =
delete;
469 Decompression_Filter& operator=(
const Decompression_Filter& other) =
delete;
470 Decompression_Filter& operator=(Decompression_Filter&& other) =
delete;
473 std::unique_ptr<Decompression_Algorithm> m_comp;
474 std::size_t m_buffersize;
475 secure_vector<uint8_t> m_buffer;
485 std::string
name()
const override {
return "Base64_Encoder"; }
492 void write(
const uint8_t input[],
size_t length)
override;
497 void end_msg()
override;
506 size_t line_length = 72,
507 bool trailing_newline =
false);
510 void encode_and_send(
const uint8_t input[],
size_t length,
bool final_inputs =
false);
511 void do_output(
const uint8_t output[],
size_t length);
513 const size_t m_line_length;
514 const bool m_trailing_newline;
515 std::vector<uint8_t> m_in, m_out;
516 size_t m_position = 0;
517 size_t m_out_position = 0;
525 std::string
name()
const override {
return "Base64_Decoder"; }
532 void write(
const uint8_t input[],
size_t length)
override;
537 void end_msg()
override;
548 std::vector<uint8_t> m_in;
549 std::vector<uint8_t> m_out;
550 size_t m_position = 0;
564 std::string
name()
const override {
return "Hex_Encoder"; }
566 void write(
const uint8_t in[],
size_t length)
override;
567 void end_msg()
override;
584 void encode_and_send(
const uint8_t input[],
size_t length);
587 const size_t m_line_length;
588 std::vector<uint8_t> m_in;
589 std::vector<uint8_t> m_out;
590 size_t m_position = 0;
591 size_t m_counter = 0;
599 std::string
name()
const override {
return "Hex_Decoder"; }
601 void write(
const uint8_t input[],
size_t length)
override;
602 void end_msg()
override;
613 std::vector<uint8_t> m_in, m_out;
614 size_t m_position = 0;
622 void write(
const uint8_t [],
size_t )
override {
625 std::string
name()
const override {
return "BitBucket"; }
636 void write(
const uint8_t input[],
size_t length)
override {
send(input, length); }
638 std::string
name()
const override {
return "Chain"; }
664 void write(
const uint8_t input[],
size_t length)
override {
send(input, length); }
668 std::string
name()
const override {
return "Fork"; }
683#if defined(BOTAN_HAS_THREAD_UTILS)
692 std::string name()
const override;
697 Threaded_Fork(Filter* f1, Filter* f2, Filter* f3 =
nullptr, Filter* f4 =
nullptr);
704 Threaded_Fork(Filter* filter_arr[],
size_t length);
706 ~Threaded_Fork()
override;
708 Threaded_Fork(
const Threaded_Fork& other) =
delete;
709 Threaded_Fork(Threaded_Fork&& other) =
delete;
710 Threaded_Fork& operator=(
const Threaded_Fork& other) =
delete;
711 Threaded_Fork& operator=(Threaded_Fork&& other) =
delete;
714 void set_next(Filter* f[],
size_t n);
715 void send(
const uint8_t in[],
size_t length)
override;
716 void thread_delegate_work(
const uint8_t input[],
size_t length);
717 void thread_entry(Filter* filter);
719 std::vector<std::shared_ptr<std::thread>> m_threads;
720 std::unique_ptr<struct Threaded_Fork_Data> m_thread_data;
#define BOTAN_PUBLIC_API(maj, min)
#define BOTAN_FUTURE_EXPLICIT
Base64_Decoder(Decoder_Checking checking=NONE)
std::string name() const override
std::string name() const override
BOTAN_FUTURE_EXPLICIT Base64_Encoder(bool line_breaks=false, size_t line_length=72, bool trailing_newline=false)
std::string name() const override
void write(const uint8_t[], size_t) override
virtual ~Buffered_Filter()=default
void write(const std::vector< uint8_t, Alloc > &in, size_t length)
size_t current_position() const
virtual void buffered_block(const uint8_t input[], size_t length)=0
Buffered_Filter(size_t block_size, size_t final_minimum)
virtual void buffered_final(const uint8_t input[], size_t length)=0
size_t buffered_block_size() const
void write(const uint8_t in[], size_t length)
void write(const uint8_t input[], size_t length) override
BOTAN_FUTURE_EXPLICIT Chain(Filter *f1=nullptr, Filter *f2=nullptr, Filter *f3=nullptr, Filter *f4=nullptr)
std::string name() const override
Cipher_Mode_Filter(std::unique_ptr< Cipher_Mode > t)
Cipher_Mode_Filter(Cipher_Mode *t)
static std::unique_ptr< Cipher_Mode > create_or_throw(std::string_view algo, Cipher_Dir direction, std::string_view provider="")
Filter(const Filter &)=delete
virtual void send(const uint8_t in[], size_t length)
virtual std::string name() const =0
std::string name() const override
void write(const uint8_t input[], size_t length) override
Fork(Filter *f1, Filter *f2, Filter *f3=nullptr, Filter *f4=nullptr)
Hex_Decoder(Decoder_Checking checking=NONE)
std::string name() const override
std::string name() const override
Hex_Encoder(Case the_case)
virtual void set_key(const SymmetricKey &key)=0
bool valid_keylength(size_t length) const
virtual void set_iv(const InitializationVector &iv)
virtual bool valid_iv_length(size_t length) const
virtual Key_Length_Specification key_spec() const =0
OctetString InitializationVector
std::vector< T, secure_allocator< T > > secure_vector
Keyed_Filter * get_cipher(std::string_view algo_spec, Cipher_Dir direction)