Dear Kevin Sopp, I know you are interested in this library I have looked at your code and have decided to use considerable amount of your library's concepts. Dear All, You may know that I have been working on a crypto library for boost. I think at this time the design and concepts for the library is finished and implementation could be started. However, I decided to check with interested parties before I begin the implementation. Currently the concepts is as follows: [Note] C++0x features has been used but there is a work around library which allows pre-C++0x compilers to compile the code. auto concept BlockCipherTraits { enum cipher_type { feistle, substitution_permutation, square, }; static constexpr size_t block_size; static constexpr size_t min_key_size; static constexpr size_t max_key_size; static constexpr cipher_type type(); static constexpr bool timming_attack_resistant; }; template<typename T=byte_t> auto concept PaddingTraits { static constexpr size_t block_size; static constexpr size_t min_block_size; /* = sizeof(T) * 2; */ static constexpr size_t max_block_size; /* = detail::pow<2,sizeof(T)*8>::value; */ static constexpr const char* name(); }; class crypto_exception; class cipher_state; class invalid_length; class invalid_key_size; class invalid_iv_size; class bad_padding; template<typename T> auto concept Padding requires PaddingTraits<T> { typename size_type; typename value_type; static constexpr size_t output_size(size_t ); static constexpr size_t pad(value_type* output, const value_type* input, size_t input_size) throw(invalid_length); static constexpr size_t unpad(value_type* output, const value_type* input, size_t input_size) throw(bad_padding); }; template<typename T> auto concept BlockCipher { typename value_type; typename size_type; const void setkey(const value_type* key, size_type key_size) throw(invalid_key_size); const void encrypt(value_type* ctxt, const value_type* ptxt); const void decrypt(value_type* ptxt, const value_type* ctxt); }; template<typename T = byte_t> auto concept StreamCipherTraits { typename value_type; static constexpr size_t min_stream_size; static constexpr size_t max_stream_size; static constexpr size_t transform_size; static constexpr size_t min_key_size; static constexpr size_t max_key_size; static constexpr size_t min_iv_size; static constexpr size_t max_iv_size; static constexpr bool seekable_stream; static constexpr bool synchronous; static constexpr bool asynchronous; }; template<StreamCipherTraits StreamCipherT> auto concept StreamCipher : StreamCipherT { typedef value_type; typedef StreamCipherT traits_type; const void setkey(const value_type* key, size_type key_size) throw(invalid_key_size); const void setivconst value_type* iv, size_type iv_size) throw(invalid_iv_size); const void encrypt(value_type* output, const value_type* input, size_type input_size); const void decrypt(value_type* output, const value_type* input,size_type input_size); }; // mode of operation + block cipher == stream_cipher template<typename T=byte_t, BlockCipher Cipher> auto concept ModeOfOperation: public StreamCipher { typedef Cipher block_cipher_type; }; template<typename T=byte_t> auto concept HashFunctionTraits: StreamCipherTraits { static constexpr size_t transform_size; static constexpr size_t digest_size; }; template<typename T=byte_t, HashFunctionTraits HashFunctionT> auto concept HashFunction : public HashFunctionT { typedef HashFunctionT traits_type; size_t digest_size() const; constexpr create(); template<size_t N> constexpr update(const crypto_buffer_t<N>& input); constexpr finalise(); template<size_t N> constexpr compute(crypto_buffer_t<traits_type::digest_size>& digest, const crypto_buffer_t <N>& input); }; class crypto_streambuf; class crypto_istream; class crypto_ostream; class crypto_iostream; Also I would like to make this library compatible with boost.iostream so that an encryption algorithm could be used as a filter for the boost.iostream. The library tries to do most of the computation at compile time. I would welcome all comments. With Best regards Kasra