/* * Buffered Computation * (C) 1999-2007 Jack Lloyd * * Distributed under the terms of the Botan license */ #ifndef BOTAN_BUFFERED_COMPUTATION_H__ #define BOTAN_BUFFERED_COMPUTATION_H__ #include #include #include namespace Botan { /** * This class represents any kind of computation which uses an internal * state, such as hash functions or MACs */ class BOTAN_DLL Buffered_Computation { public: /** * @return length of the output of this function in bytes */ virtual size_t output_length() const = 0; /** * Add new input to process. * @param in the input to process as a byte array * @param length of param in in bytes */ void update(const byte in[], size_t length) { add_data(in, length); } /** * Add new input to process. * @param in the input to process as a secure_vector */ void update(const secure_vector& in) { add_data(&in[0], in.size()); } /** * Add new input to process. * @param in the input to process as a std::vector */ void update(const std::vector& in) { add_data(&in[0], in.size()); } /** * Add an integer in big-endian order * @param in the value */ template void update_be(const T in) { for(size_t i = 0; i != sizeof(T); ++i) { byte b = get_byte(i, in); add_data(&b, 1); } } /** * Add new input to process. * @param str the input to process as a std::string. Will be interpreted * as a byte array based on * the strings encoding. */ void update(const std::string& str) { add_data(reinterpret_cast(str.data()), str.size()); } /** * Process a single byte. * @param in the byte to process */ void update(byte in) { add_data(&in, 1); } /** * Complete the computation and retrieve the * final result. * @param out The byte array to be filled with the result. * Must be of length output_length() */ void final(byte out[]) { final_result(out); } /** * Complete the computation and retrieve the * final result. * @return secure_vector holding the result */ secure_vector final() { secure_vector output(output_length()); final_result(&output[0]); return output; } /** * Update and finalize computation. Does the same as calling update() * and final() consecutively. * @param in the input to process as a byte array * @param length the length of the byte array * @result the result of the call to final() */ secure_vector process(const byte in[], size_t length) { add_data(in, length); return final(); } /** * Update and finalize computation. Does the same as calling update() * and final() consecutively. * @param in the input to process * @result the result of the call to final() */ secure_vector process(const secure_vector& in) { add_data(&in[0], in.size()); return final(); } secure_vector process(const std::vector& in) { add_data(&in[0], in.size()); return final(); } /** * Update and finalize computation. Does the same as calling update() * and final() consecutively. * @param in the input to process as a string * @result the result of the call to final() */ secure_vector process(const std::string& in) { update(in); return final(); } virtual ~Buffered_Computation() {} private: /** * Add more data to the computation * @param input is an input buffer * @param length is the length of input in bytes */ virtual void add_data(const byte input[], size_t length) = 0; /** * Write the final output to out * @param out is an output buffer of output_length() */ virtual void final_result(byte out[]) = 0; }; } #endif