nil::crypto3 Namespace Reference

Namespaces
	accumulators
	adaptors
	algebra
	block
	codec
	detail
	hash
	hashes
	kdf
	mac
	math
	passhash
	pbkdf
	pubkey
	stream
	stream_endian
	vdf
	zk

Classes
struct	accumulator_set
class	cpuid
struct	digest
struct	emsa
	EMSA, from IEEE 1363s Encoding Method for Signatures, Appendix. More...
struct	iso_9796
struct	iso_9796_ds2
struct	iso_9796_ds3
class	memory_pool
class	mlock_allocator
class	secure_allocator
class	static_digest

Typedefs
template<std::size_t DigestBits>
using	digest = boost::container::small_vector< octet_type, DigestBits/octet_bits >
template<typename Hash >
using	hashing_to_curve_accumulator_set = boost::accumulators::accumulator_set< typename Hash::result_type, boost::accumulators::features< hashes::accumulators::tag::to_curve< Hash > >>
	Accumulator set with pre-defined hashing to curve accumulator params. More...
typedef boost::uint_t< octet_bits >::least	octet_type

Functions
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>, typename AggregationAccumulator = typename pubkey::aggregation_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate (const SinglePassRange &range)
	Aggregation of the input signatures into one resulted signature. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::aggregation_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregation accumulator with input signatures. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	aggregate (const SinglePassRange &range, OutputIterator out)
	Aggregation of the input signatures into one resulted signature and writing it in out. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>, typename AggregationAccumulator = typename pubkey::aggregation_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate (InputIterator first, InputIterator last)
	Aggregation of the input signatures into one resulted signature. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::aggregation_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregation accumulator with input signatures. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::aggregation_processing_mode_default<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	aggregate (InputIterator first, InputIterator last, OutputIterator out)
	Aggregation of the input signatures into one resulted signature and writing it in out. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate_verify (const SinglePassRange &range, const pubkey::public_key< Scheme > &key, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregate verification accumulator with input message and corresponding public key. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename AggregateVerificationAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregateVerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate_verify (const SinglePassRange &range, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key)
	Aggregate verification of the input aggregated signature that aggregates signature created for the input message on the key. More...
template<typename Scheme , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate_verify (const typename pubkey::public_key< Scheme >::signature_type &aggregated_signature, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregate verification accumulator with verified aggregated signature. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate_verify (InputIterator first, InputIterator last, const pubkey::public_key< Scheme > &key, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregate verification accumulator with input message and corresponding public key. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename AggregateVerificationAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregateVerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate_verify (InputIterator first, InputIterator last, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key)
	Aggregate verification of the input aggregated signature that aggregates signature created for the input message on the key. More...
template<typename Scheme , typename OutputIterator , typename ProcessingMode = pubkey::aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputIterator >::type	aggregate_verify (OutputAccumulator &acc, OutputIterator out)
	Extracting of accumulator set acc containing aggregate verification accumulator and writing result in out. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::single_msg_aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate_verify_single_msg (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregate verification accumulator with input message or public keys. More...
template<typename Scheme , typename SinglePassRange1 , typename SinglePassRange2 , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>, typename AggregateVerificationAccumulator = pubkey::single_msg_aggregate_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregateVerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate_verify_single_msg (const SinglePassRange1 &msg_rng, const SinglePassRange2 &keys_rng, const typename pubkey::public_key< Scheme >::signature_type &signature)
	Aggregate verification of the input aggregated signature that is aggregation of signatures created for the single input message on the input list of key. More...
template<typename Scheme , typename SinglePassRange1 , typename SinglePassRange2 , typename OutputIterator , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>>
OutputIterator	aggregate_verify_single_msg (const SinglePassRange1 &msg_rng, const SinglePassRange2 &keys_rng, const typename pubkey::public_key< Scheme >::signature_type &signature, OutputIterator out)
	Aggregate verification of the input aggregated signature that is aggregation of signatures created for the single input message on the input list of key and writing result in out. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::single_msg_aggregate_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	aggregate_verify_single_msg (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of accumulator set acc containing aggregate verification accumulator with input message or public keys. More...
template<typename Scheme , typename InputIterator1 , typename InputIterator2 , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>, typename AggregateVerificationAccumulator = pubkey::single_msg_aggregate_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<AggregateVerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	aggregate_verify_single_msg (InputIterator1 msg_first, InputIterator1 msg_last, InputIterator2 key_first, InputIterator2 key_last, const typename pubkey::public_key< Scheme >::signature_type &signature)
	Aggregate verification of the input aggregated signature that is aggregation of signatures created for the single input message on the input list of key. More...
template<typename Scheme , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename ProcessingMode = pubkey::single_msg_aggregate_verification_processing_mode_default<Scheme>>
OutputIterator	aggregate_verify_single_msg (InputIterator1 msg_first, InputIterator1 msg_last, InputIterator2 key_first, InputIterator2 key_last, const typename pubkey::public_key< Scheme >::signature_type &signature, OutputIterator out)
	Aggregate verification of the input aggregated signature that is aggregation of signatures created for the single input message on the input list of key and writing result in out. More...
BOOST_ATTRIBUTE_MALLOC_FUNCTION void *	allocate_memory (size_t elems, size_t elem_size)
uint8_t *	cast_char_ptr_to_uint8 (char *s)
const uint8_t *	cast_char_ptr_to_uint8 (const char *s)
const char *	cast_uint8_ptr_to_char (const uint8_t *b)
char *	cast_uint8_ptr_to_char (uint8_t *b)
bool	check_bcrypt (const std::string &password, const std::string &hash)
void	clear_bytes (void *ptr, size_t bytes)
template<typename T >
void	clear_mem (T *ptr, size_t n)
template<typename Mac , typename SinglePassRange , typename OutputAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	compute (const SinglePassRange &r, OutputAccumulator &acc)
template<typename Mac , typename SinglePassRange , typename MacAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>, typename StreamMacImpl = mac::detail::value_mac_impl<MacAccumulator>, typename MacImpl = mac::detail::range_mac_impl<StreamMacImpl>>
MacImpl	compute (const SinglePassRange &rng, const mac::mac_key< Mac > &key)
template<typename Mac , typename SinglePassRange , typename OutputIterator >
OutputIterator	compute (const SinglePassRange &rng, const mac::mac_key< Mac > &key, OutputIterator out)
template<typename Mac , typename InputIterator , typename MacAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>, typename StreamMacImpl = mac::detail::value_mac_impl<MacAccumulator>, typename MacImpl = mac::detail::range_mac_impl<StreamMacImpl>>
MacImpl	compute (InputIterator first, InputIterator last, const mac::mac_key< Mac > &key)
template<typename Mac , typename InputIterator , typename OutputIterator >
OutputIterator	compute (InputIterator first, InputIterator last, const mac::mac_key< Mac > &key, OutputIterator out)
template<typename Mac , typename InputIterator , typename OutputAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	compute (InputIterator first, InputIterator last, OutputAccumulator &acc)
bool	constant_time_compare (const uint8_t x[], const uint8_t y[], size_t len)
template<typename T >
void	copy_mem (T *out, const T *in, size_t n)
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::share_dealing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	deal_share (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of share dealing accumulator set using shares, dealt by other participant for the current. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::share_dealing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	deal_share (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of share dealing accumulator set using shares, dealt by other participant for the current. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::share_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_share (std::size_t i, const SinglePassRange &range)
	Deal share of specified participant using passed shares, dealt by other participant for the current. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_share (std::size_t i, const SinglePassRange &range, OutputIterator out)
	Deal share of specified participant using passed shares, dealt by other participant for the current. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::share_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_share (std::size_t i, InputIterator first, InputIterator last)
	Deal share of specified participant using passed shares, dealt by other participant for the current. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::share_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_share (std::size_t i, InputIterator first, InputIterator last, OutputIterator out)
	Deal share of specified participant using passed shares, dealt by other participant for the current. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	deal_shares (const SinglePassRange &range, OutputAccumulator &acc)
	Updating shares dealing accumulator with polynomial coefficients. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_shares (const SinglePassRange &range, std::size_t n)
	Deal shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_shares (const SinglePassRange &range, std::size_t n, const typename Scheme::weights_type &weights)
	Deal weighted shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_shares (const SinglePassRange &range, std::size_t n, const typename Scheme::weights_type &weights, OutputIterator out)
	Deal weighted shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_shares (const SinglePassRange &range, std::size_t n, OutputIterator out)
	Deal shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	deal_shares (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating shares dealing accumulator with polynomial coefficients. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_shares (InputIterator first, InputIterator last, std::size_t n)
	Deal shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>, typename DealingAccumulator = typename pubkey::shares_dealing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<DealingAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	deal_shares (InputIterator first, InputIterator last, std::size_t n, const typename Scheme::weights_type &weights)
	Deal weighted shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_shares (InputIterator first, InputIterator last, std::size_t n, const typename Scheme::weights_type &weights, OutputIterator out)
	Deal weighted shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::shares_dealing_processing_mode_default<Scheme>>
OutputIterator	deal_shares (InputIterator first, InputIterator last, std::size_t n, OutputIterator out)
	Deal shares using passed polynomial coefficients, threshold number of participants required to reconstruct secret equals to number of the coefficients. More...
void	deallocate_memory (void *p, size_t elems, size_t elem_size)
template<typename Decoder , typename SinglePassRange , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	decode (const SinglePassRange &r)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Decoder , typename SinglePassRange , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	decode (const SinglePassRange &rng, CodecAccumulator &acc)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Decoder , typename SinglePassRange , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	decode (const SinglePassRange &rng, OutputIterator out)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Decoder , typename InputIterator , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	decode (InputIterator first, InputIterator last)
	Decodes the elements with particular codec defined with Decoder in the range, defined by [first, last) and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Decoder , typename InputIterator , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	decode (InputIterator first, InputIterator last, CodecAccumulator &acc)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Decoder , typename InputIterator , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	decode (InputIterator first, InputIterator last, OutputIterator out)
	Decodes the elements with particular codec defined with Decoder in the range, defined by [first, last), and inserts the result to another range beginning at out. More...
template<typename Decoder , typename T , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	decode (std::initializer_list< T > r)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Decoder , typename T , typename CodecAccumulator = typename codec::accumulator_set<typename Decoder::stream_decoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	decode (std::initializer_list< T > rng, CodecAccumulator &acc)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Decoder , typename T , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	decode (std::initializer_list< T > rng, OutputIterator out)
	Decodes the elements with particular codec defined with Decoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename BlockCipher , typename SinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (const SinglePassRange &r, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename SinglePassRange , typename KeyPassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (const SinglePassRange &r, const KeyPassRange &key)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_decrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	decrypt (const SinglePassRange &r, const KeyRange &key)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (const SinglePassRange &r, const KeySinglePassRange &key)
template<typename BlockCipher , typename SinglePassRange , typename OutputAccumulator = typename block::accumulator_set< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::template bind< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::decryption_policy>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename CipherMode , typename SinglePassRange , typename OutputAccumulator = typename block::accumulator_set< typename CipherMode::template bind<typename CipherMode::decryption_policy>::type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename StreamCipher , typename SinglePassRange , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_decrypter_type>>
OutputAccumulator &	decrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	decrypt (const SinglePassRange &range, const pubkey::decryption_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename OutputIterator >
OutputIterator	decrypt (const SinglePassRange &range, const pubkey::decryption_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (const SinglePassRange &range, OutputAccumulator &acc)
template<typename BlockCipher , typename SinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator	decrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange &	decrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator	decrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputIterator out)
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputRange >
OutputRange &	decrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputRange &out)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename OutputIterator >
OutputIterator	decrypt (const SinglePassRange &rng, const KeyRange &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator	decrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange &	decrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputRange &out)
template<typename BlockCipher , typename InputIterator , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename InputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	decrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key)
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::decryption_policy<CipherMode>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key)
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	decrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator	decrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	decrypt (InputIterator first, InputIterator last, const pubkey::decryption_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename OutputIterator >
OutputIterator	decrypt (InputIterator first, InputIterator last, const pubkey::decryption_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last)
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::decryption_policy<CipherMode>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last)
template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator	decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_decrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename OutputIterator >
OutputIterator	decrypt (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename OutputAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename CipherMode , typename InputIterator , typename OutputAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::decryption_policy<CipherMode>>::type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename StreamCipher , typename InputIterator , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_decrypter_type>>
OutputAccumulator &	decrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename BlockCipher , typename InputIterator , typename K , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	decrypt (InputIterator first, InputIterator last, std::initializer_list< K > key, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (InputIterator first, InputIterator last, std::initializer_list< KeySinglePassRange > key)
template<typename BlockCipher , typename T , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (std::initializer_list< T > r, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename T , typename OutputAccumulator = typename block::accumulator_set< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::template bind< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::decryption_policy>::type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	decrypt (std::initializer_list< T > r, OutputAccumulator &acc)
template<typename BlockCipher , typename T , typename K , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	decrypt (std::initializer_list< T > r, std::initializer_list< K > key)
template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator	decrypt (std::initializer_list< T > rng, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename T , typename OutputRange >
OutputRange &	decrypt (std::initializer_list< T > rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator	decrypt (std::initializer_list< T > rng, std::initializer_list< K > key, OutputIterator out)
template<typename BlockCipher , typename T , typename K , typename OutputRange >
OutputRange &	decrypt (std::initializer_list< T > rng, std::initializer_list< K > key, OutputRange &out)
template<typename Encoder , typename SinglePassRange , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	encode (const SinglePassRange &r)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Encoder , typename SinglePassRange , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	encode (const SinglePassRange &rng, CodecAccumulator &acc)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Encoder , typename SinglePassRange , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	encode (const SinglePassRange &rng, OutputIterator out)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Encoder , typename InputIterator , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	encode (InputIterator first, InputIterator last)
	Encodes the elements with particular codec defined with Encoder in the range, defined by [first, last) and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Encoder , typename InputIterator , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	encode (InputIterator first, InputIterator last, CodecAccumulator &acc)
	Encodes the elements with particular codec defined with Encoder in the range, defined by [first, last) and returns the result with type satisfying AccumulatorSet requirements. More...
template<typename Encoder , typename InputIterator , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	encode (InputIterator first, InputIterator last, OutputIterator out)
	Encodes the elements with particular codec defined with Encoder in the range, defined by [first, last), and inserts the result to another range beginning at out. More...
template<typename Encoder , typename T , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
codec::detail::range_codec_impl< codec::detail::value_codec_impl< CodecAccumulator > >	encode (std::initializer_list< T > r)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and returns the result with any type convertible to the type satisfying SequenceContainer with the value type satisfying Integral concept requirements. More...
template<typename Encoder , typename T , typename CodecAccumulator = typename codec::accumulator_set<typename Encoder::stream_encoder_type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< CodecAccumulator >::value, CodecAccumulator >::type &	encode (std::initializer_list< T > rng, CodecAccumulator &acc)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename Encoder , typename T , typename OutputIterator >
std::enable_if< detail::is_iterator< OutputIterator >::value, OutputIterator >::type	encode (std::initializer_list< T > rng, OutputIterator out)
	Encodes the elements with particular codec defined with Encoder in the range, defined by rng and inserts the result to destination range beginning at out. More...
template<typename BlockCipher , typename SinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (const SinglePassRange &r, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename SinglePassRange , typename KeyPassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (const SinglePassRange &r, const KeyPassRange &key)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	encrypt (const SinglePassRange &r, const KeyRange &key)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (const SinglePassRange &r, const KeySinglePassRange &key)
template<typename BlockCipher , typename SinglePassRange , typename OutputAccumulator = typename block::accumulator_set< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::template bind< typename block::modes::isomorphic<BlockCipher, block::nop_padding>::encryption_policy>::type>, typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename CipherMode , typename SinglePassRange , typename OutputAccumulator = typename block::accumulator_set< typename CipherMode::template bind<typename CipherMode::encryption_policy>::type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename StreamCipher , typename SinglePassRange , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
OutputAccumulator &	encrypt (const SinglePassRange &r, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	encrypt (const SinglePassRange &range, const pubkey::encryption_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename OutputIterator >
OutputIterator	encrypt (const SinglePassRange &range, const pubkey::encryption_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (const SinglePassRange &range, OutputAccumulator &acc)
template<typename BlockCipher , typename SinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator	encrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange &	encrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator	encrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputIterator out)
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputRange >
OutputRange &	encrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputRange &out)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename OutputIterator >
OutputIterator	encrypt (const SinglePassRange &rng, const KeyRange &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator	encrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputIterator out)
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange &	encrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputRange &out)
template<typename BlockCipher , typename InputIterator , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename InputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	encrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key)
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::encryption_policy<CipherMode>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key)
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	encrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator	encrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	encrypt (InputIterator first, InputIterator last, const pubkey::encryption_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename OutputIterator >
OutputIterator	encrypt (InputIterator first, InputIterator last, const pubkey::encryption_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last)
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::encryption_policy<CipherMode>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last)
template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator	encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator	encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename OutputIterator >
OutputIterator	encrypt (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last, OutputIterator out)
template<typename BlockCipher , typename InputIterator , typename OutputAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename CipherMode , typename InputIterator , typename OutputAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::encryption_policy<CipherMode>>::type>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	encrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename StreamCipher , typename InputIterator , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
OutputAccumulator &	encrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename BlockCipher , typename InputIterator , typename K , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (InputIterator first, InputIterator last, std::initializer_list< K > key)
template<typename BlockCipher , typename SinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (std::initializer_list< SinglePassRange > r, const block::cipher_key< BlockCipher > &key)
template<typename BlockCipher , typename T , typename K , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>>
block::detail::range_cipher_impl< block::detail::value_cipher_impl< CipherAccumulator > >	encrypt (std::initializer_list< T > il, std::initializer_list< K > key)
template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator	encrypt (std::initializer_list< T > r, const block::cipher_key< BlockCipher > &key, OutputIterator out)
template<typename BlockCipher , typename T , typename OutputRange >
OutputRange &	encrypt (std::initializer_list< T > r, const block::cipher_key< BlockCipher > &key, OutputRange &out)
template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator	encrypt (std::initializer_list< T > r, std::initializer_list< K > key, OutputIterator out)
template<typename BlockCipher , typename T , typename K , typename OutputRange >
OutputRange &	encrypt (std::initializer_list< T > r, std::initializer_list< K > key, OutputRange &out)
template<typename UniformRandomGenerator >
std::string	generate_bcrypt (const std::string &password, UniformRandomGenerator &rng, uint16_t work_factor=10)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::keypair_generation_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	generate_keypair (const SinglePassRange &range, const pubkey::keypair_generation_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::keypair_generation_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	generate_keypair (InputIterator first, InputIterator last, const pubkey::keypair_generation_init_params_type< Scheme > &init_params)
template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< HashAccumulator > >	hash (const SinglePassRange &r)
template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type &	hash (const SinglePassRange &rng, HashAccumulator &sh)
template<typename Hash , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type	hash (const SinglePassRange &rng, OutputIterator out)
template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< typename std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type > >	hash (InputIterator first, InputIterator last)
template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type &	hash (InputIterator first, InputIterator last, HashAccumulator &sh)
template<typename Hash , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	hash (InputIterator first, InputIterator last, OutputIterator out)
template<typename Hash , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type	hash (std::initializer_list< T > list, OutputIterator out)
template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< HashAccumulator > >	hash (std::initializer_list< T > r)
template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type &	hash (std::initializer_list< T > rng, HashAccumulator &sh)
void	initialize_allocator ()
template<std::size_t N, typename RandomAccessIterator >
std::array< detail::ValueType< RandomAccessIterator >, N >	make_array (RandomAccessIterator first, RandomAccessIterator last)
template<std::size_t DB>
bool	operator!= (char const *b, const static_digest< DB > &a)
template<unsigned DB>
bool	operator!= (char const *b, digest< DB > const &a)
template<unsigned DB1, unsigned DB2>
bool	operator!= (const digest< DB1 > &a, const digest< DB2 > &b)
template<typename T , typename U >
bool	operator!= (const secure_allocator< T > &, const secure_allocator< U > &)
template<std::size_t DB>
bool	operator!= (const static_digest< DB > &a, char const *b)
template<std::size_t DB1, std::size_t DB2>
bool	operator!= (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<unsigned DB>
bool	operator!= (digest< DB > const &a, char const *b)
template<unsigned DB1, unsigned DB2>
bool	operator< (const digest< DB1 > &a, const digest< DB2 > &b)
template<std::size_t DB1, std::size_t DB2>
bool	operator< (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<std::size_t DigestBits>
std::ostream &	operator<< (std::ostream &sink, const static_digest< DigestBits > &d)
template<unsigned DB>
std::ostream &	operator<< (std::ostream &sink, digest< DB > const &d)
template<unsigned DB1, unsigned DB2>
bool	operator<= (const digest< DB1 > &a, const digest< DB2 > &b)
template<std::size_t DB1, std::size_t DB2>
bool	operator<= (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<std::size_t DB>
bool	operator== (char const *b, const static_digest< DB > &a)
template<unsigned DB>
bool	operator== (char const *b, digest< DB > const &a)
template<unsigned DB1, unsigned DB2>
bool	operator== (const digest< DB1 > &a, const digest< DB2 > &b)
template<typename T , typename U >
bool	operator== (const secure_allocator< T > &, const secure_allocator< U > &)
template<std::size_t DB>
bool	operator== (const static_digest< DB > &a, char const *b)
template<std::size_t DB1, std::size_t DB2>
bool	operator== (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<unsigned DB>
bool	operator== (digest< DB > const &a, char const *b)
template<unsigned DB1, unsigned DB2>
bool	operator> (const digest< DB1 > &a, const digest< DB2 > &b)
template<std::size_t DB1, std::size_t DB2>
bool	operator> (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<unsigned DB1, unsigned DB2>
bool	operator>= (const digest< DB1 > &a, const digest< DB2 > &b)
template<std::size_t DB1, std::size_t DB2>
bool	operator>= (const static_digest< DB1 > &a, const static_digest< DB2 > &b)
template<unsigned DB>
std::istream &	operator>> (std::istream &source, digest< DB > &d)
template<std::size_t DigestBits>
std::istream &	operator>> (std::istream &source, static_digest< DigestBits > &d)
template<typename Alloc , typename Alloc2 >
std::vector< uint8_t, Alloc > &	operator^= (std::vector< uint8_t, Alloc > &out, const std::vector< uint8_t, Alloc2 > &in)
template<typename Container >
void	poly_double_n (const Container &c)
template<typename InputIterator >
void	poly_double_n (uint8_t out[], InputIterator first, InputIterator last)
template<typename InputIterator >
void	poly_double_n_le (uint8_t out[], InputIterator first, InputIterator last)
constexpr bool	poly_double_supported_size (size_t n)
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>, typename ReconstructionAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<ReconstructionAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	reconstruct_public_secret (const SinglePassRange &range)
	Reconstruct public representative of secret using passed public representatives of shares. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>, typename OutputAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	reconstruct_public_secret (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of reconstructing accumulator set using passed public representatives of shares. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	reconstruct_public_secret (const SinglePassRange &range, OutputIterator out)
	Reconstruct public representative of secret using passed public representatives of shares. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>, typename ReconstructionAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<ReconstructionAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	reconstruct_public_secret (InputIterator first, InputIterator last)
	Reconstruct public representative of secret using passed public representatives of shares. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>, typename OutputAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	reconstruct_public_secret (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of reconstructing accumulator set using passed public representatives of shares. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::public_secret_reconstructing_processing_mode<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	reconstruct_public_secret (InputIterator first, InputIterator last, OutputIterator out)
	Reconstruct public representative of secret using passed public representatives of shares. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>, typename ReconstructionAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<ReconstructionAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	reconstruct_secret (const SinglePassRange &range)
	Reconstruct secret using passed shares. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	reconstruct_secret (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of reconstructing accumulator set using passed shares. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	reconstruct_secret (const SinglePassRange &range, OutputIterator out)
	Reconstruct secret using passed shares. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>, typename ReconstructionAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<ReconstructionAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	reconstruct_secret (InputIterator first, InputIterator last)
	Reconstruct secret using passed shares. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::reconstructing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	reconstruct_secret (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of reconstructing accumulator set using passed shares. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::secret_reconstructing_processing_mode_default<Scheme>>
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	reconstruct_secret (InputIterator first, InputIterator last, OutputIterator out)
	Reconstruct secret using passed shares. More...
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	rerandomize (const SinglePassRange &range, const pubkey::rerandomization_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename OutputIterator >
OutputIterator	rerandomize (const SinglePassRange &range, const pubkey::rerandomization_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	rerandomize (const SinglePassRange &range, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	rerandomize (const SinglePassRange1 &range1, const SinglePassRange2 &range2, const pubkey::rerandomization_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputIterator >
OutputIterator	rerandomize (const SinglePassRange1 &range1, const SinglePassRange2 &range2, const pubkey::rerandomization_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	rerandomize (const SinglePassRange1 &range1, const SinglePassRange2 &range2, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	rerandomize (InputIterator first, InputIterator last, const pubkey::rerandomization_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename OutputIterator >
OutputIterator	rerandomize (InputIterator first, InputIterator last, const pubkey::rerandomization_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	rerandomize (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	rerandomize (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, const pubkey::rerandomization_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator	rerandomize (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, const pubkey::rerandomization_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	rerandomize (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputAccumulator &acc)
template<unsigned NewBits, unsigned OldBits>
digest< NewBits >	reserve (const boost::container::small_vector< octet_type, OldBits/octet_bits > &od)
template<unsigned NewBits, unsigned OldBits>
digest< NewBits >	reserve (const digest< OldBits > &od)
template<unsigned NewBits, unsigned OldBits>
digest< NewBits >	resize (const boost::container::small_vector< octet_type, OldBits/octet_bits > &od)
template<std::size_t DigestBits>
digest< DigestBits >	resize (const digest< DigestBits > &od, std::size_t new_size)
template<std::size_t NewBits, std::size_t OldBits>
static_digest< NewBits >	resize (const static_digest< OldBits > &od)
template<typename T >
bool	same_mem (const T *p1, const T *p2, size_t n)
void	secure_scrub_memory (void *ptr, size_t n)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	seek (const SinglePassRange &r, const KeyRange &key)
template<typename StreamCipher , typename SinglePassRange , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
OutputAccumulator &	seek (const SinglePassRange &r, OutputAccumulator &acc)
template<typename StreamCipher , typename SinglePassRange , typename KeyRange , typename OutputIterator >
OutputIterator	seek (const SinglePassRange &rng, const KeyRange &key, OutputIterator out)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename CipherAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
stream::detail::range_cipher_impl< stream::detail::value_cipher_impl< CipherAccumulator > >	seek (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last)
template<typename StreamCipher , typename InputIterator , typename KeyIterator , typename OutputIterator >
OutputIterator	seek (InputIterator first, InputIterator last, KeyIterator key_first, KeyIterator key_last, OutputIterator out)
template<typename StreamCipher , typename InputIterator , typename OutputAccumulator = typename stream::stream_accumulator<typename StreamCipher::stream_encrypter_type>>
OutputAccumulator &	seek (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename T >
void	set_mem (T *ptr, size_t n, uint8_t val)
template<typename Scheme , typename ProcessingMode = pubkey::pop_proving_processing_mode_default<Scheme>, typename SigningAccumulator = pubkey::signing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<SigningAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	sign (const pubkey::private_key< Scheme > &key)
	Proving of possession of the supplied key. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>, typename SigningAccumulator = pubkey::signing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<SigningAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	sign (const SinglePassRange &range, const pubkey::private_key< Scheme > &key)
	Signing of the input message on the key. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>>
OutputIterator	sign (const SinglePassRange &range, const pubkey::private_key< Scheme > &key, OutputIterator out)
	Signing of the input message on the key and writing result in out. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::signing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	sign (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of accumulator set acc containing signing accumulator with input message. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>, typename SigningAccumulator = pubkey::signing_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<SigningAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	sign (InputIterator first, InputIterator last, const pubkey::private_key< Scheme > &key)
	Signing of the input message on the key. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>>
OutputIterator	sign (InputIterator first, InputIterator last, const pubkey::private_key< Scheme > &key, OutputIterator out)
	Signing of the input message on the key and writing result in out. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::signing_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::signing_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	sign (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of accumulator set acc containing signing accumulator with input message. More...
template<typename Hash , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< HashingAccumulator > >	to_curve (const SinglePassRange &r)
template<typename Hash , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type &	to_curve (const SinglePassRange &rng, HashingAccumulator &sh)
template<typename Hash , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type	to_curve (const SinglePassRange &rng, OutputIterator out)
template<typename Hash , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< typename std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type > >	to_curve (InputIterator first, InputIterator last)
template<typename Hash , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type &	to_curve (InputIterator first, InputIterator last, HashingAccumulator &sh)
template<typename Hash , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type	to_curve (InputIterator first, InputIterator last, OutputIterator out)
template<typename Hash , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type	to_curve (std::initializer_list< T > list, OutputIterator out)
template<typename Hash , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< HashingAccumulator > >	to_curve (std::initializer_list< T > r)
template<typename Hash , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type &	to_curve (std::initializer_list< T > rng, HashingAccumulator &sh)
template<unsigned NewBits, unsigned OldBits>
digest< NewBits >	truncate (const boost::container::small_vector< octet_type, OldBits/octet_bits > &od)
template<unsigned NewBits, unsigned OldBits>
digest< NewBits >	truncate (const digest< OldBits > &od)
template<std::size_t NewBits, std::size_t OldBits>
static_digest< NewBits >	truncate (const static_digest< OldBits > &od)
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>, typename VerificationAccumulator = pubkey::verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<VerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify (const SinglePassRange &range, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key)
	Verification of the input signature for the input message on the key. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>>
OutputIterator	verify (const SinglePassRange &range, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key, OutputIterator out)
	Verification of the input signature for the input message on the key and writing result in out. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of accumulator set acc containing verification accumulator with input message. More...
template<typename Scheme , typename ProcessingMode = pubkey::pop_verification_processing_mode_default<Scheme>, typename VerificationAccumulator = pubkey::verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<VerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify (const typename pubkey::public_key< Scheme >::signature_type &proof, const pubkey::public_key< Scheme > &key)
	Verification of the proof of possession of the supplied key. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>, typename VerificationAccumulator = pubkey::verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<VerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify (InputIterator first, InputIterator last, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key)
	Verification of the input signature for the input message on the key. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>>
OutputIterator	verify (InputIterator first, InputIterator last, const typename pubkey::public_key< Scheme >::signature_type &signature, const pubkey::public_key< Scheme > &key, OutputIterator out)
	Verification of the input signature for the input message on the key and writing result in out. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::verification_processing_mode_default<Scheme>, typename OutputAccumulator = pubkey::verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of accumulator set acc containing verification accumulator with input message. More...
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_decryption (const SinglePassRange1 &range1, const SinglePassRange2 &range2, const pubkey::decryption_verification_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputIterator >
OutputIterator	verify_decryption (const SinglePassRange1 &range1, const SinglePassRange2 &range2, const pubkey::decryption_verification_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_decryption (const SinglePassRange1 &range1, const SinglePassRange2 &range2, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_decryption (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, const pubkey::decryption_verification_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator	verify_decryption (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, const pubkey::decryption_verification_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_decryption (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_encryption (const SinglePassRange &range, const pubkey::encryption_verification_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename OutputIterator >
OutputIterator	verify_encryption (const SinglePassRange &range, const pubkey::encryption_verification_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_encryption (const SinglePassRange &range, OutputAccumulator &acc)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_encryption (InputIterator first, InputIterator last, const pubkey::encryption_verification_init_params_type< Scheme > &init_params)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename OutputIterator >
OutputIterator	verify_encryption (InputIterator first, InputIterator last, const pubkey::encryption_verification_init_params_type< Scheme > &init_params, OutputIterator out)
template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_encryption (InputIterator first, InputIterator last, OutputAccumulator &acc)
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>, typename VerificationAccumulator = typename pubkey::share_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<VerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_share (const SinglePassRange &range, const pubkey::public_share_sss< Scheme > &s)
	Verification of the share on the input public representatives of polynomial coefficients. More...
template<typename Scheme , typename SinglePassRange , typename OutputIterator , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>>
OutputIterator	verify_share (const SinglePassRange &range, const pubkey::public_share_sss< Scheme > &s, OutputIterator out)
	Verification of the share on the input public representatives of polynomial coefficients. More...
template<typename Scheme , typename SinglePassRange , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::share_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_share (const SinglePassRange &range, OutputAccumulator &acc)
	Updating of accumulator set acc containing verification accumulator with public representatives of polynomial coefficients. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>, typename VerificationAccumulator = typename pubkey::share_verification_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<VerificationAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>
SchemeImpl	verify_share (InputIterator first, InputIterator last, const pubkey::public_share_sss< Scheme > &s)
	Verification of the share on the input public representatives of polynomial coefficients. More...
template<typename Scheme , typename InputIterator , typename OutputIterator , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>>
OutputIterator	verify_share (InputIterator first, InputIterator last, const pubkey::public_share_sss< Scheme > &s, OutputIterator out)
	Verification of the share on the input public representatives of polynomial coefficients. More...
template<typename Scheme , typename InputIterator , typename ProcessingMode = pubkey::share_verification_processing_mode_default<Scheme>, typename OutputAccumulator = typename pubkey::share_verification_accumulator_set<ProcessingMode>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type &	verify_share (InputIterator first, InputIterator last, OutputAccumulator &acc)
	Updating of accumulator set acc containing verification accumulator with public representatives of polynomial coefficients. More...
template<typename Alloc , typename Alloc2 >
void	xor_buf (std::vector< uint8_t, Alloc > &out, const std::vector< uint8_t, Alloc2 > &in, size_t n)
template<typename Alloc , typename Alloc2 >
void	xor_buf (std::vector< uint8_t, Alloc > &out, const uint8_t *in, const std::vector< uint8_t, Alloc2 > &in2, size_t n)
template<typename Alloc >
void	xor_buf (std::vector< uint8_t, Alloc > &out, const uint8_t *in, size_t n)
void	xor_buf (uint8_t out[], const uint8_t in[], const uint8_t in2[], size_t length)
void	xor_buf (uint8_t out[], const uint8_t in[], size_t length)

Typedef Documentation

digest

template<std::size_t DigestBits>

using nil::crypto3::digest = typedef boost::container::small_vector<octet_type, DigestBits / octet_bits>

The digest class template stores a DigestBits-bit message digest as a sequence of 8-bit octets. Octets are stored in the smallest unsigned type able to hold 8 bits, hereinafter referred to as octet_type. DigestBits must be a multiple of 8.

It is independent of any particular algorithm; For example sha2<224> and cubehash<224> both produce a digest<224>. Each algorithm generates its digest such that it will be displayed in the canonical order for that algorithm. The truncate and resize function templates are provided to handle digests with lengths other than you're expecting. For instance, generating name-based UUIDs uses only 128 bits but SHA-1 provides a 160-bit digest, so it would be truncated. (Using truncate instead of resize means that a compilation error will result from trying to use a hash algorithm with too small an output.) On the other hand, for storing as much as possible of the results of various algorithms, resize allows you to pad them out to a large size, such as a digest<512>.

digest<DigestBits> derives publicly from std::array<octet_type, DigestBits/8> and supports all of its operations in order to provide direct access to the contained octets. Note that a digest is not an aggregate; A default-constructed digest has all its contained octets set to zero. The base_array() member function provides a reference to the std::array sub-object.

digests with different numbers of bits may be compared. For the comparison, the smaller is considered as though it were padded with 0s out to the size of the larger. The operator< provides a strict total order. For convenience, equality comparison with narrow c-style strings is also provided.

Always stored internally as a sequence of octets in display order. This allows digests from different algorithms to have the same type, allowing them to be more easily stored and compared.

Template Parameters

DigestBits

octet_type

typedef boost::uint_t< octet_bits >::least nil::crypto3::octet_type

Function Documentation

allocate_memory()

BOOST_ATTRIBUTE_MALLOC_FUNCTION void* nil::crypto3::allocate_memory	(	size_t	elems,
		size_t	elem_size
	)

Allocate a memory buffer by some method. This should only be used for primitive types (uint8_t, uint32_t, etc).

Parameters

elems	the number of elements
elem_size	the size of each element

Returns

pointer to allocated and zeroed memory, or throw std::bad_alloc on failure

cast_char_ptr_to_uint8() [1/2]

uint8_t* nil::crypto3::cast_char_ptr_to_uint8 ( char *  s )

inline

cast_char_ptr_to_uint8() [2/2]

const uint8_t* nil::crypto3::cast_char_ptr_to_uint8 ( const char *  s )

inline

cast_uint8_ptr_to_char() [1/2]

const char* nil::crypto3::cast_uint8_ptr_to_char ( const uint8_t *  b )

inline

cast_uint8_ptr_to_char() [2/2]

char* nil::crypto3::cast_uint8_ptr_to_char ( uint8_t *  b )

inline

check_bcrypt()

bool nil::crypto3::check_bcrypt	(	const std::string &	password,
		const std::string &	hash
	)

Check a previously created password hash

Parameters

password	the password to check against
hash	the stored hash to check against

clear_bytes()

void nil::crypto3::clear_bytes ( void *  ptr, size_t  bytes  )

inline

Zero out some bytes

Parameters

ptr	a pointer to memory to zero
bytes	the number of bytes to zero in ptr

clear_mem()

template<typename T >

void nil::crypto3::clear_mem ( T *  ptr, size_t  n  )

inline

Zero memory before use. This simply calls memset and should not be used in cases where the compiler cannot see the call as a side-effecting operation (for example, if calling clear_mem before deallocating memory, the compiler would be allowed to omit the call to memset entirely under the as-if rule.)

Parameters

ptr	a pointer to an array of Ts to zero
n	the number of Ts pointed to by ptr

compute() [1/4]

template<typename Mac , typename SinglePassRange , typename MacAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>, typename StreamMacImpl = mac::detail::value_mac_impl<MacAccumulator>, typename MacImpl = mac::detail::range_mac_impl<StreamMacImpl>>

MacImpl nil::crypto3::compute	(	const SinglePassRange &	rng,
		const mac::mac_key< Mac > &	key
	)

Template Parameters

Mac
OutputRange
SinglePassRange

Parameters

rng

Returns

compute() [2/4]

template<typename Mac , typename SinglePassRange , typename OutputIterator >

OutputIterator nil::crypto3::compute	(	const SinglePassRange &	rng,
		const mac::mac_key< Mac > &	key,
		OutputIterator	out
	)

Template Parameters

Mac
SinglePassRange
OutputIterator

Parameters

rng
out

Returns

compute() [3/4]

template<typename Mac , typename InputIterator , typename MacAccumulator = mac::computation_accumulator_set<mac::computation_policy<Mac>>, typename StreamMacImpl = mac::detail::value_mac_impl<MacAccumulator>, typename MacImpl = mac::detail::range_mac_impl<StreamMacImpl>>

MacImpl nil::crypto3::compute	(	InputIterator	first,
		InputIterator	last,
		const mac::mac_key< Mac > &	key
	)

Template Parameters

Mac
InputIterator
OutputIterator

Parameters

first
last

Returns

compute() [4/4]

template<typename Mac , typename InputIterator , typename OutputIterator >

OutputIterator nil::crypto3::compute	(	InputIterator	first,
		InputIterator	last,
		const mac::mac_key< Mac > &	key,
		OutputIterator	out
	)

Template Parameters

Mac
InputIterator
OutputIterator

Parameters

first
last
out

Returns

constant_time_compare()

bool nil::crypto3::constant_time_compare	(	const uint8_t	x[],
		const uint8_t	y[],
		size_t	len
	)

Memory comparison, input insensitive

Parameters

x	a pointer to an array
y	a pointer to another array
len	the number of Ts in x and y

Returns

true iff x[i] == y[i] forall i in [0...n)

copy_mem()

template<typename T >

void nil::crypto3::copy_mem ( T *  out, const T *  in, size_t  n  )

inline

Copy memory

Parameters

out	the destination array
in	the source array
n	the number of elements of in/out

deallocate_memory()

void nil::crypto3::deallocate_memory	(	void *	p,
		size_t	elems,
		size_t	elem_size
	)

Free a pointer returned by allocate_memory

Parameters

p	the pointer returned by allocate_memory
elems	the number of elements, as passed to allocate_memory
elem_size	the size of each element, as passed to allocate_memory

decrypt() [1/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::decrypt	(	const SinglePassRange &	range,
		const pubkey::decryption_init_params_type< Scheme > &	init_params
	)

decrypt() [2/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename OutputIterator >

OutputIterator nil::crypto3::decrypt	(	const SinglePassRange &	range,
		const pubkey::decryption_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

decrypt() [3/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename SinglePassRange , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::decrypt	(	const SinglePassRange &	range,
		OutputAccumulator &	acc
	)

decrypt() [4/12]

template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputRange >

OutputRange& nil::crypto3::decrypt	(	const SinglePassRange &	rng,
		const KeyPassRange &	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
SinglePassRange
KeyPassRange
OutputRange

Parameters

rng
key
out

Returns

decrypt() [5/12]

template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>

OutputRange& nil::crypto3::decrypt	(	const SinglePassRange &	rng,
		const KeySinglePassRange &	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
SinglePassRange
KeySinglePassRange
OutputRange

Parameters

rng
key
out

Returns

decrypt() [6/12]

template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		const KeySinglePassRange &	key
	)

Template Parameters

BlockCipher
InputIterator
KeySinglePassRange
CipherAccumulator

Parameters

first
last
key

Returns

decrypt() [7/12]

template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::decryption_policy<CipherMode>>::type>>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		const KeySinglePassRange &	key
	)

Template Parameters

BlockCipher
InputIterator
KeySinglePassRange
CipherAccumulator

Parameters

first
last
key

Returns

decrypt() [8/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		const pubkey::decryption_init_params_type< Scheme > &	init_params
	)

decrypt() [9/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename OutputIterator >

OutputIterator nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		const pubkey::decryption_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

decrypt() [10/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::decryption_policy, typename InputIterator , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		OutputAccumulator &	acc
	)

decrypt() [11/12]

template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::decryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::decrypt	(	InputIterator	first,
		InputIterator	last,
		std::initializer_list< KeySinglePassRange >	key
	)

Template Parameters

BlockCipher
InputIterator
KeySinglePassRange
CipherAccumulator

Parameters

first
last
key

Returns

decrypt() [12/12]

template<typename BlockCipher , typename T , typename K , typename OutputRange >

OutputRange& nil::crypto3::decrypt	(	std::initializer_list< T >	rng,
		std::initializer_list< K >	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
T
K
OutputRange

Parameters

rng
key
out

Returns

encrypt() [1/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::encrypt	(	const SinglePassRange &	range,
		const pubkey::encryption_init_params_type< Scheme > &	init_params
	)

encrypt() [2/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename OutputIterator >

OutputIterator nil::crypto3::encrypt	(	const SinglePassRange &	range,
		const pubkey::encryption_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

encrypt() [3/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename SinglePassRange , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::encrypt	(	const SinglePassRange &	range,
		OutputAccumulator &	acc
	)

encrypt() [4/12]

template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputRange >

OutputRange& nil::crypto3::encrypt	(	const SinglePassRange &	rng,
		const KeyPassRange &	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
SinglePassRange
KeyPassRange
OutputRange

Parameters

rng
key
out

Returns

encrypt() [5/12]

template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>

OutputRange& nil::crypto3::encrypt	(	const SinglePassRange &	rng,
		const KeySinglePassRange &	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
SinglePassRange
KeySinglePassRange
OutputRange

Parameters

rng
key
out

Returns

encrypt() [6/12]

template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		const KeySinglePassRange &	key
	)

Template Parameters

BlockCipher
InputIterator
KeySinglePassRange
CipherAccumulator

Parameters

first
last
key

Returns

encrypt() [7/12]

template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename CipherAccumulator = typename block::accumulator_set< typename CipherMode::template bind<block::encryption_policy<CipherMode>>::type>>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		const KeySinglePassRange &	key
	)

Template Parameters

BlockCipher
InputIterator
KeySinglePassRange
CipherAccumulator

Parameters

first
last
key

Returns

encrypt() [8/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		const pubkey::encryption_init_params_type< Scheme > &	init_params
	)

encrypt() [9/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename OutputIterator >

OutputIterator nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		const pubkey::encryption_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

encrypt() [10/12]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::encryption_policy, typename InputIterator , typename OutputAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		OutputAccumulator &	acc
	)

encrypt() [11/12]

template<typename BlockCipher , typename InputIterator , typename K , typename CipherAccumulator = typename block::accumulator_set<typename block::modes::isomorphic< BlockCipher, block::nop_padding>::template bind<block::encryption_policy<BlockCipher>>::type>, typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>

block::detail::range_cipher_impl<block::detail::value_cipher_impl<CipherAccumulator> > nil::crypto3::encrypt	(	InputIterator	first,
		InputIterator	last,
		std::initializer_list< K >	key
	)

Template Parameters

BlockCipher
InputIterator
K
CipherAccumulator

Parameters

first
last
key

Returns

encrypt() [12/12]

template<typename BlockCipher , typename T , typename K , typename OutputRange >

OutputRange& nil::crypto3::encrypt	(	std::initializer_list< T >	r,
		std::initializer_list< K >	key,
		OutputRange &	out
	)

Template Parameters

BlockCipher
T
K
OutputRange

Parameters

r
key
out

Returns

generate_bcrypt()

template<typename UniformRandomGenerator >

std::string nil::crypto3::generate_bcrypt	(	const std::string &	password,
		UniformRandomGenerator &	rng,
		uint16_t	work_factor = 10
	)

Create a password hash using Bcrypt

Parameters

password	the password
rng	a random number generator
work_factor	how much work to do to slow down guessing attacks

See also

https://www.usenix.org/events/usenix99/provos/provos_html/

generate_keypair() [1/2]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::keypair_generation_policy, typename SinglePassRange , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::generate_keypair	(	const SinglePassRange &	range,
		const pubkey::keypair_generation_init_params_type< Scheme > &	init_params
	)

generate_keypair() [2/2]

template<typename Scheme , typename Mode = pubkey::modes::isomorphic<Scheme>, typename ProcessingMode = typename Mode::keypair_generation_policy, typename InputIterator , typename PubkeyAccumulator = pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::generate_keypair	(	InputIterator	first,
		InputIterator	last,
		const pubkey::keypair_generation_init_params_type< Scheme > &	init_params
	)

initialize_allocator()

void nil::crypto3::initialize_allocator

(

)

Ensure the allocator is initialized

make_array()

template<std::size_t N, typename RandomAccessIterator >

std::array< detail::ValueType< RandomAccessIterator >, N > nil::crypto3::make_array	(	RandomAccessIterator	first,
		RandomAccessIterator	last
	)

operator!=() [1/7]

template<std::size_t DB>

bool nil::crypto3::operator!=	(	char const *	b,
		const static_digest< DB > &	a
	)

operator!=() [2/7]

template<unsigned DB>

bool nil::crypto3::operator!=	(	char const *	b,
		digest< DB > const &	a
	)

operator!=() [3/7]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator!=	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator!=() [4/7]

template<typename T , typename U >

bool nil::crypto3::operator!= ( const secure_allocator< T > &  , const secure_allocator< U > &    )

inline

operator!=() [5/7]

template<std::size_t DB>

bool nil::crypto3::operator!=	(	const static_digest< DB > &	a,
		char const *	b
	)

operator!=() [6/7]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator!=	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator!=() [7/7]

template<unsigned DB>

bool nil::crypto3::operator!=	(	digest< DB > const &	a,
		char const *	b
	)

operator<() [1/2]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator<	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator<() [2/2]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator<	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator<<() [1/2]

template<std::size_t DigestBits>

std::ostream & nil::crypto3::operator<<	(	std::ostream &	sink,
		const static_digest< DigestBits > &	d
	)

operator<<() [2/2]

template<unsigned DB>

std::ostream & nil::crypto3::operator<<	(	std::ostream &	sink,
		digest< DB > const &	d
	)

operator<=() [1/2]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator<=	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator<=() [2/2]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator<=	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator==() [1/7]

template<std::size_t DB>

bool nil::crypto3::operator==	(	char const *	b,
		const static_digest< DB > &	a
	)

operator==() [2/7]

template<unsigned DB>

bool nil::crypto3::operator==	(	char const *	b,
		digest< DB > const &	a
	)

operator==() [3/7]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator==	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator==() [4/7]

template<typename T , typename U >

bool nil::crypto3::operator== ( const secure_allocator< T > &  , const secure_allocator< U > &    )

inline

operator==() [5/7]

template<std::size_t DB>

bool nil::crypto3::operator==	(	const static_digest< DB > &	a,
		char const *	b
	)

operator==() [6/7]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator==	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator==() [7/7]

template<unsigned DB>

bool nil::crypto3::operator==	(	digest< DB > const &	a,
		char const *	b
	)

operator>() [1/2]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator>	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator>() [2/2]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator>	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator>=() [1/2]

template<unsigned DB1, unsigned DB2>

bool nil::crypto3::operator>=	(	const digest< DB1 > &	a,
		const digest< DB2 > &	b
	)

operator>=() [2/2]

template<std::size_t DB1, std::size_t DB2>

bool nil::crypto3::operator>=	(	const static_digest< DB1 > &	a,
		const static_digest< DB2 > &	b
	)

operator>>() [1/2]

template<unsigned DB>

std::istream & nil::crypto3::operator>>	(	std::istream &	source,
		digest< DB > &	d
	)

operator>>() [2/2]

template<std::size_t DigestBits>

std::istream & nil::crypto3::operator>>	(	std::istream &	source,
		static_digest< DigestBits > &	d
	)

operator^=()

template<typename Alloc , typename Alloc2 >

std::vector<uint8_t, Alloc>& nil::crypto3::operator^=	(	std::vector< uint8_t, Alloc > &	out,
		const std::vector< uint8_t, Alloc2 > &	in
	)

poly_double_n() [1/2]

template<typename Container >

void nil::crypto3::poly_double_n ( const Container &  c )

inline

poly_double_n() [2/2]

template<typename InputIterator >

void nil::crypto3::poly_double_n	(	uint8_t	out[],
		InputIterator	first,
		InputIterator	last
	)

Polynomial doubling in GF(2^n)

poly_double_n_le()

template<typename InputIterator >

void nil::crypto3::poly_double_n_le	(	uint8_t	out[],
		InputIterator	first,
		InputIterator	last
	)

poly_double_supported_size()

constexpr bool nil::crypto3::poly_double_supported_size ( size_t  n )

inlineconstexpr

Returns true iff poly_double_n is implemented for this size.

rerandomize() [1/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::rerandomize	(	const SinglePassRange &	range,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params
	)

rerandomize() [2/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename OutputIterator >

OutputIterator nil::crypto3::rerandomize	(	const SinglePassRange &	range,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

rerandomize() [3/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::rerandomize	(	const SinglePassRange &	range,
		OutputAccumulator &	acc
	)

rerandomize() [4/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::rerandomize	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params
	)

rerandomize() [5/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputIterator >

OutputIterator nil::crypto3::rerandomize	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

rerandomize() [6/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::rerandomize	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		OutputAccumulator &	acc
	)

rerandomize() [7/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::rerandomize	(	InputIterator	first,
		InputIterator	last,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params
	)

rerandomize() [8/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename OutputIterator >

OutputIterator nil::crypto3::rerandomize	(	InputIterator	first,
		InputIterator	last,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

rerandomize() [9/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::rerandomize	(	InputIterator	first,
		InputIterator	last,
		OutputAccumulator &	acc
	)

rerandomize() [10/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::rerandomize	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params
	)

rerandomize() [11/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename OutputIterator >

OutputIterator nil::crypto3::rerandomize	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		const pubkey::rerandomization_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

rerandomize() [12/12]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::rerandomization_policy, typename InputIterator1 , typename InputIterator2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::rerandomize	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		OutputAccumulator &	acc
	)

reserve() [1/2]

template<unsigned NewBits, unsigned OldBits>

digest<NewBits> nil::crypto3::reserve

(

const boost::container::small_vector< octet_type, OldBits/octet_bits > &

od

)

Template Parameters

NewBits
OldBits

Parameters

od

Returns

Digest containing the first min(NewBits, OldBits) bits of the argument digest followed by max (0, NewBits - OldBits) bits.

reserve() [2/2]

template<unsigned NewBits, unsigned OldBits>

digest< NewBits > nil::crypto3::reserve

(

const digest< OldBits > &

od

)

Template Parameters

NewBits
OldBits

Parameters

od

Returns

Digest containing the first min(NewBits, OldBits) bits of the argument digest followed by max (0, NewBits - OldBits) bits.

resize() [1/3]

template<unsigned NewBits, unsigned OldBits>

digest< NewBits > nil::crypto3::resize

(

const boost::container::small_vector< octet_type, OldBits/octet_bits > &

od

)

Template Parameters

NewBits
OldBits

Parameters

od

Returns

Digest containing the first min(NewBits, OldBits) bits of the argument digest followed by max (0, NewBits - OldBits) bits.

resize() [2/3]

template<std::size_t DigestBits>

digest< DigestBits > nil::crypto3::resize	(	const digest< DigestBits > &	od,
		std::size_t	new_size
	)

Template Parameters

DigestBits

Parameters

od
new_size

Returns

Digest containing the first min(od.size(), new_size) octets of the argument digest followed by max (0, new_size - od.size()) zero octets.

resize() [3/3]

template<std::size_t NewBits, std::size_t OldBits>

static_digest< NewBits > nil::crypto3::resize

(

const static_digest< OldBits > &

od

)

Template Parameters

NewBits
OldBits

Parameters

od

Returns

Digest containing the first min(NewBits, OldBits) bits of the argument digest followed by max (0, NewBits - OldBits) bits.

same_mem()

template<typename T >

bool nil::crypto3::same_mem ( const T *  p1, const T *  p2, size_t  n  )

inline

Memory comparison, input insensitive

Parameters

p1	a pointer to an array
p2	a pointer to another array
n	the number of Ts in p1 and p2

Returns

true iff p1[i] == p2[i] forall i in [0...n)

secure_scrub_memory()

void nil::crypto3::secure_scrub_memory	(	void *	ptr,
		size_t	n
	)

Scrub memory contents in a way that a compiler should not elide, using some system specific technique. Note that this function might not zero the memory (for example, in some hypothetical implementation it might combine the memory contents with the output of a system PRNG), but if you can detect any difference in behavior at runtime then the clearing is side-effecting and you can just use clear_mem.

Use this function to scrub memory just before deallocating it, or on a stack buffer before returning from the function.

Parameters

ptr	a pointer to memory to scrub
n	the number of bytes pointed to by ptr

set_mem()

template<typename T >

void nil::crypto3::set_mem ( T *  ptr, size_t  n, uint8_t  val  )

inline

Set memory to a fixed value

Parameters

ptr	a pointer to an array
n	the number of Ts pointed to by ptr
val	the value to set each byte to

truncate() [1/3]

template<unsigned NewBits, unsigned OldBits>

digest< NewBits > nil::crypto3::truncate

(

const boost::container::small_vector< octet_type, OldBits/octet_bits > &

od

)

Template Parameters

NewBits
OldBits

Returns

Digest containing only the first NewBits bits of the argument digest.

Requires that NewBits <= OldBits.

Truncating a message digest generally does not weaken the hash algorithm beyond the amount necessitated by the shorted output size.

truncate() [2/3]

template<unsigned NewBits, unsigned OldBits>

digest< NewBits > nil::crypto3::truncate

(

const digest< OldBits > &

od

)

Template Parameters

NewBits
OldBits

Returns

Digest containing only the first NewBits bits of the argument digest.

Requires that NewBits <= OldBits.

Truncating a message digest generally does not weaken the hash algorithm beyond the amount necessitated by the shorted output size.

truncate() [3/3]

template<std::size_t NewBits, std::size_t OldBits>

static_digest< NewBits > nil::crypto3::truncate

(

const static_digest< OldBits > &

od

)

Template Parameters

NewBits
OldBits

Returns

Digest containing only the first NewBits bits of the argument digest.

Requires that NewBits <= OldBits.

Truncating a message digest generally does not weaken the hash algorithm beyond the amount necessitated by the shorted output size.

verify_decryption() [1/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::verify_decryption	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		const pubkey::decryption_verification_init_params_type< Scheme > &	init_params
	)

verify_decryption() [2/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputIterator >

OutputIterator nil::crypto3::verify_decryption	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		const pubkey::decryption_verification_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

verify_decryption() [3/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename SinglePassRange1 , typename SinglePassRange2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::verify_decryption	(	const SinglePassRange1 &	range1,
		const SinglePassRange2 &	range2,
		OutputAccumulator &	acc
	)

verify_decryption() [4/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::verify_decryption	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		const pubkey::decryption_verification_init_params_type< Scheme > &	init_params
	)

verify_decryption() [5/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename OutputIterator >

OutputIterator nil::crypto3::verify_decryption	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		const pubkey::decryption_verification_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

verify_decryption() [6/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::decryption_verification_policy, typename InputIterator1 , typename InputIterator2 , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::verify_decryption	(	InputIterator1	first1,
		InputIterator1	last1,
		InputIterator2	first2,
		InputIterator2	last2,
		OutputAccumulator &	acc
	)

verify_encryption() [1/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::verify_encryption	(	const SinglePassRange &	range,
		const pubkey::encryption_verification_init_params_type< Scheme > &	init_params
	)

verify_encryption() [2/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename OutputIterator >

OutputIterator nil::crypto3::verify_encryption	(	const SinglePassRange &	range,
		const pubkey::encryption_verification_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

verify_encryption() [3/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename SinglePassRange , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::verify_encryption	(	const SinglePassRange &	range,
		OutputAccumulator &	acc
	)

verify_encryption() [4/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename PubkeyAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>, typename StreamSchemeImpl = pubkey::detail::value_pubkey_impl<PubkeyAccumulator>, typename SchemeImpl = pubkey::detail::range_pubkey_impl<StreamSchemeImpl>>

SchemeImpl nil::crypto3::verify_encryption	(	InputIterator	first,
		InputIterator	last,
		const pubkey::encryption_verification_init_params_type< Scheme > &	init_params
	)

verify_encryption() [5/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename OutputIterator >

OutputIterator nil::crypto3::verify_encryption	(	InputIterator	first,
		InputIterator	last,
		const pubkey::encryption_verification_init_params_type< Scheme > &	init_params,
		OutputIterator	out
	)

verify_encryption() [6/6]

template<typename Scheme , typename Mode = pubkey::modes::verifiable_encryption<Scheme>, typename ProcessingMode = typename Mode::encryption_verification_policy, typename InputIterator , typename OutputAccumulator = typename pubkey::pubkey_accumulator_set<ProcessingMode>>

std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::verify_encryption	(	InputIterator	first,
		InputIterator	last,
		OutputAccumulator &	acc
	)

xor_buf() [1/5]

template<typename Alloc , typename Alloc2 >

void nil::crypto3::xor_buf	(	std::vector< uint8_t, Alloc > &	out,
		const std::vector< uint8_t, Alloc2 > &	in,
		size_t	n
	)

xor_buf() [2/5]

template<typename Alloc , typename Alloc2 >

void nil::crypto3::xor_buf	(	std::vector< uint8_t, Alloc > &	out,
		const uint8_t *	in,
		const std::vector< uint8_t, Alloc2 > &	in2,
		size_t	n
	)

xor_buf() [3/5]

template<typename Alloc >

void nil::crypto3::xor_buf	(	std::vector< uint8_t, Alloc > &	out,
		const uint8_t *	in,
		size_t	n
	)

xor_buf() [4/5]

void nil::crypto3::xor_buf ( uint8_t  out[], const uint8_t  in[], const uint8_t  in2[], size_t  length  )

inline

XOR arrays. Postcondition out[i] = in[i] ^ in2[i] forall i = 0...length

Parameters

out	the output buffer
in	the first input buffer
in2	the second output buffer
length	the length of the three buffers

xor_buf() [5/5]

void nil::crypto3::xor_buf ( uint8_t  out[], const uint8_t  in[], size_t  length  )

inline

XOR arrays. Postcondition out[i] = in[i] ^ out[i] forall i = 0...length

Parameters

out	the input/output buffer
in	the read-only input buffer
length	the length of the buffers