nil::crypto3 Namespace Reference

Namespaces

 accumulators
 
 adaptors
 
 algebra
 
 block
 
 codec
 
 detail
 
 fft
 
 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)
 
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 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 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 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 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 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 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 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<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 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
elemsthe number of elements
elem_sizethe 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
passwordthe password to check against
hashthe stored hash to check against

◆ clear_bytes()

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

Zero out some bytes

Parameters
ptra pointer to memory to zero
bytesthe 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
ptra pointer to an array of Ts to zero
nthe number of Ts pointed to by ptr

◆ 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
xa pointer to an array
ya pointer to another array
lenthe 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
outthe destination array
inthe source array
nthe 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
pthe pointer returned by allocate_memory
elemsthe number of elements, as passed to allocate_memory
elem_sizethe size of each element, as passed to allocate_memory

◆ decrypt() [1/6]

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() [2/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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/6]

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() [2/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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
passwordthe password
rnga random number generator
work_factorhow much work to do to slow down guessing attacks
See also
https://www.usenix.org/events/usenix99/provos/provos_html/

◆ 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.

◆ 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
p1a pointer to an array
p2a pointer to another array
nthe 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
ptra pointer to memory to scrub
nthe 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
ptra pointer to an array
nthe number of Ts pointed to by ptr
valthe 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.

◆ 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
outthe output buffer
inthe first input buffer
in2the second output buffer
lengththe 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
outthe input/output buffer
inthe read-only input buffer
lengththe length of the buffers