Algorithms are meant to provide encryption interface similar to STL algorithms' one. More...

+ Collaboration diagram for Algorithms:

Functions

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 > > nil::crypto3::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 > > nil::crypto3::decrypt (const SinglePassRange &r, const KeyPassRange &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 > > nil::crypto3::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 & nil::crypto3::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 & nil::crypto3::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 nil::crypto3::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 & nil::crypto3::decrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
 
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator nil::crypto3::decrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputIterator out)
 
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::decrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputIterator 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 > > nil::crypto3::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 nil::crypto3::decrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key, OutputIterator out)
 
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::decrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
 
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator nil::crypto3::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 > > nil::crypto3::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 > > nil::crypto3::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 nil::crypto3::decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
 
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator nil::crypto3::decrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator 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 & nil::crypto3::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 & nil::crypto3::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 nil::crypto3::decrypt (InputIterator first, InputIterator last, std::initializer_list< K > key, OutputIterator out)
 
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 > > nil::crypto3::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 & nil::crypto3::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 > > nil::crypto3::decrypt (std::initializer_list< T > r, std::initializer_list< K > key)
 
template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator nil::crypto3::decrypt (std::initializer_list< T > rng, const block::cipher_key< BlockCipher > &key, OutputIterator out)
 
template<typename BlockCipher , typename T , typename OutputRange >
OutputRange & nil::crypto3::decrypt (std::initializer_list< T > rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
 
template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator nil::crypto3::decrypt (std::initializer_list< T > rng, std::initializer_list< K > key, OutputIterator out)
 
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 > > nil::crypto3::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 > > nil::crypto3::encrypt (const SinglePassRange &r, const KeyPassRange &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 > > nil::crypto3::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 & nil::crypto3::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 & nil::crypto3::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 nil::crypto3::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 & nil::crypto3::encrypt (const SinglePassRange &rng, const block::cipher_key< BlockCipher > &key, OutputRange &out)
 
template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator nil::crypto3::encrypt (const SinglePassRange &rng, const KeyPassRange &key, OutputIterator out)
 
template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::encrypt (const SinglePassRange &rng, const KeySinglePassRange &key, OutputIterator 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 > > nil::crypto3::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 nil::crypto3::encrypt (InputIterator first, InputIterator last, const block::cipher_key< BlockCipher > &key, OutputIterator out)
 
template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::encrypt (InputIterator first, InputIterator last, const KeySinglePassRange &key, OutputIterator out)
 
template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator nil::crypto3::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 > > nil::crypto3::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 > > nil::crypto3::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 nil::crypto3::encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator key_last, OutputIterator out)
 
template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator nil::crypto3::encrypt (InputIterator first, InputIterator last, KeyInputIterator key_first, KeyInputIterator 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 & nil::crypto3::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 & nil::crypto3::encrypt (InputIterator first, InputIterator last, OutputAccumulator &acc)
 
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 > > nil::crypto3::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 > > nil::crypto3::encrypt (std::initializer_list< T > il, std::initializer_list< K > key)
 
template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator nil::crypto3::encrypt (std::initializer_list< T > r, const block::cipher_key< BlockCipher > &key, OutputIterator out)
 
template<typename BlockCipher , typename T , typename OutputRange >
OutputRange & nil::crypto3::encrypt (std::initializer_list< T > r, const block::cipher_key< BlockCipher > &key, OutputRange &out)
 
template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator nil::crypto3::encrypt (std::initializer_list< T > r, std::initializer_list< K > key, OutputIterator out)
 

Detailed Description

Algorithms are meant to provide encryption interface similar to STL algorithms' one.

Function Documentation

◆ decrypt() [1/26]

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> > nil::crypto3::decrypt ( const SinglePassRange &  r,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
SinglePassRange
CipherAccumulator
Parameters
r
key
Returns

◆ decrypt() [2/26]

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> > nil::crypto3::decrypt ( const SinglePassRange &  r,
const KeyPassRange &  key 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
CipherAccumulator
Parameters
r
key
Returns

◆ decrypt() [3/26]

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> > nil::crypto3::decrypt ( const SinglePassRange &  r,
const KeySinglePassRange &  key 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
CipherAccumulator
Parameters
r
key
Returns

◆ decrypt() [4/26]

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& nil::crypto3::decrypt ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
SinglePassRange
OutputAccumulator
Parameters
r
acc
Returns

◆ decrypt() [5/26]

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& nil::crypto3::decrypt ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
SinglePassRange
OutputAccumulator
Parameters
r
acc
Returns

◆ decrypt() [6/26]

template<typename BlockCipher , typename SinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::decrypt ( const SinglePassRange &  rng,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
OutputIterator
Parameters
rng
key
out
Returns

◆ decrypt() [7/26]

template<typename BlockCipher , typename SinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange& nil::crypto3::decrypt ( const SinglePassRange &  rng,
const block::cipher_key< BlockCipher > &  key,
OutputRange &  out 
)
Template Parameters
BlockCipher
SinglePassRange
OutputRange
Parameters
rng
key
out
Returns

◆ decrypt() [8/26]

template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator nil::crypto3::decrypt ( const SinglePassRange &  rng,
const KeyPassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
OutputIterator
Parameters
rng
key
out
Returns

◆ decrypt() [9/26]

template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::decrypt ( const SinglePassRange &  rng,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
OutputIterator
Parameters
rng
key
out
Returns

◆ decrypt() [10/26]

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> > nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
InputIterator
CipherAccumulator
Parameters
first
last
key
Returns

◆ decrypt() [11/26]

template<typename BlockCipher , typename InputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
OutputIterator
Parameters
first
last
key
out
Returns

◆ decrypt() [12/26]

template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeySinglePassRange
OutputIterator
Parameters
first
last
key
out
Returns

◆ decrypt() [13/26]

template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeySinglePassRange
OutputIterator
Parameters
first
last
key
out
Returns

◆ decrypt() [14/26]

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> > nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
CipherAccumulator
Parameters
first
last
key_first
key_last
Returns

◆ decrypt() [15/26]

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> > nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
CipherAccumulator
Parameters
first
last
key_first
key_last
Returns

◆ decrypt() [16/26]

template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
OutputIterator
Parameters
first
last
key_first
key_last
out
Returns

◆ decrypt() [17/26]

template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
OutputIterator
Parameters
first
last
key_first
key_last
out
Returns

◆ decrypt() [18/26]

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& nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
InputIterator
OutputAccumulator
Parameters
first
last
acc
Returns

◆ decrypt() [19/26]

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& nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
InputIterator
OutputAccumulator
Parameters
first
last
acc
Returns

◆ decrypt() [20/26]

template<typename BlockCipher , typename InputIterator , typename K , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::decrypt ( InputIterator  first,
InputIterator  last,
std::initializer_list< K >  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
K
OutputIterator
Parameters
first
last
key
out
Returns

◆ decrypt() [21/26]

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> > nil::crypto3::decrypt ( std::initializer_list< T >  r,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
T
CipherAccumulator
Parameters
r
key
Returns

◆ decrypt() [22/26]

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& nil::crypto3::decrypt ( std::initializer_list< T >  r,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
T
OutputAccumulator
Parameters
r
acc
Returns

◆ decrypt() [23/26]

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> > nil::crypto3::decrypt ( std::initializer_list< T >  r,
std::initializer_list< K >  key 
)
Template Parameters
BlockCipher
T
KeyRange
CipherAccumulator
Parameters
r
key
Returns

◆ decrypt() [24/26]

template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator nil::crypto3::decrypt ( std::initializer_list< T >  rng,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
T
OutputIterator
Parameters
rng
key
out
Returns

◆ decrypt() [25/26]

template<typename BlockCipher , typename T , typename OutputRange >
OutputRange& nil::crypto3::decrypt ( std::initializer_list< T >  rng,
const block::cipher_key< BlockCipher > &  key,
OutputRange &  out 
)
Template Parameters
BlockCipher
T
OutputRange
Parameters
rng
key
out
Returns

◆ decrypt() [26/26]

template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator nil::crypto3::decrypt ( std::initializer_list< T >  rng,
std::initializer_list< K >  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
T
KeyRange
OutputIterator
Parameters
rng
key
out
Returns

◆ encrypt() [1/24]

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> > nil::crypto3::encrypt ( const SinglePassRange &  r,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
SinglePassRange
CipherAccumulator
Parameters
r
key
Returns

◆ encrypt() [2/24]

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> > nil::crypto3::encrypt ( const SinglePassRange &  r,
const KeyPassRange &  key 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
CipherAccumulator
Parameters
r
key
Returns

◆ encrypt() [3/24]

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> > nil::crypto3::encrypt ( const SinglePassRange &  r,
const KeySinglePassRange &  key 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
CipherAccumulator
Parameters
r
key
Returns

◆ encrypt() [4/24]

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& nil::crypto3::encrypt ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
SinglePassRange
OutputAccumulator
Parameters
r
acc
Returns

◆ encrypt() [5/24]

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& nil::crypto3::encrypt ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
SinglePassRange
OutputAccumulator
Parameters
r
acc
Returns

◆ encrypt() [6/24]

template<typename BlockCipher , typename SinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::encrypt ( const SinglePassRange &  rng,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
OutputIterator
Parameters
rng
key
out
Returns

◆ encrypt() [7/24]

template<typename BlockCipher , typename SinglePassRange , typename OutputRange , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputRange& nil::crypto3::encrypt ( const SinglePassRange &  rng,
const block::cipher_key< BlockCipher > &  key,
OutputRange &  out 
)
Template Parameters
BlockCipher
SinglePassRange
OutputRange
Parameters
rng
key
out
Returns

◆ encrypt() [8/24]

template<typename CipherMode , typename SinglePassRange , typename KeyPassRange , typename OutputIterator >
OutputIterator nil::crypto3::encrypt ( const SinglePassRange &  rng,
const KeyPassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
OutputIterator
Parameters
rng
key
out
Returns

◆ encrypt() [9/24]

template<typename BlockCipher , typename SinglePassRange , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_range<SinglePassRange>::value>::type>
OutputIterator nil::crypto3::encrypt ( const SinglePassRange &  rng,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
SinglePassRange
KeyRange
OutputIterator
Parameters
rng
key
out
Returns

◆ encrypt() [10/24]

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> > nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
InputIterator
CipherAccumulator
Parameters
first
last
key
Returns

◆ encrypt() [11/24]

template<typename BlockCipher , typename InputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
OutputIterator
Parameters
first
last
key
out
Returns

◆ encrypt() [12/24]

template<typename BlockCipher , typename InputIterator , typename KeySinglePassRange , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeySinglePassRange
OutputIterator
Parameters
first
last
key
out
Returns

◆ encrypt() [13/24]

template<typename CipherMode , typename InputIterator , typename KeySinglePassRange , typename OutputIterator >
OutputIterator nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
const KeySinglePassRange &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeySinglePassRange
OutputIterator
Parameters
first
last
key
out
Returns

◆ encrypt() [14/24]

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> > nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
CipherAccumulator
Parameters
first
last
key_first
key_last
Returns

◆ encrypt() [15/24]

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> > nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
CipherAccumulator
Parameters
first
last
key_first
key_last
Returns

◆ encrypt() [16/24]

template<typename BlockCipher , typename InputIterator , typename KeyInputIterator , typename OutputIterator , typename = typename std::enable_if<detail::is_iterator<InputIterator>::value>::type>
OutputIterator nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
OutputIterator
Parameters
first
last
key_first
key_last
out
Returns

◆ encrypt() [17/24]

template<typename CipherMode , typename InputIterator , typename KeyInputIterator , typename OutputIterator >
OutputIterator nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
KeyInputIterator  key_first,
KeyInputIterator  key_last,
OutputIterator  out 
)
Template Parameters
BlockCipher
InputIterator
KeyIterator
OutputIterator
Parameters
first
last
key_first
key_last
out
Returns

◆ encrypt() [18/24]

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& nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
InputIterator
OutputAccumulator
Parameters
first
last
acc
Returns

◆ encrypt() [19/24]

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& nil::crypto3::encrypt ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
BlockCipher
InputIterator
OutputAccumulator
Parameters
first
last
acc
Returns

◆ encrypt() [20/24]

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> > nil::crypto3::encrypt ( std::initializer_list< SinglePassRange >  r,
const block::cipher_key< BlockCipher > &  key 
)
Template Parameters
BlockCipher
SinglePassRange
CipherAccumulator
Parameters
r
key
Returns

◆ encrypt() [21/24]

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> > nil::crypto3::encrypt ( std::initializer_list< T >  il,
std::initializer_list< K >  key 
)
Template Parameters
BlockCipher
T
KeyRange
CipherAccumulator
Parameters
il
key
Returns

◆ encrypt() [22/24]

template<typename BlockCipher , typename T , typename OutputIterator >
OutputIterator nil::crypto3::encrypt ( std::initializer_list< T >  r,
const block::cipher_key< BlockCipher > &  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
T
OutputIterator
Parameters
r
key
out
Returns

◆ encrypt() [23/24]

template<typename BlockCipher , typename T , typename OutputRange >
OutputRange& nil::crypto3::encrypt ( std::initializer_list< T >  r,
const block::cipher_key< BlockCipher > &  key,
OutputRange &  out 
)
Template Parameters
BlockCipher
T
OutputRange
Parameters
r
key
out
Returns

◆ encrypt() [24/24]

template<typename BlockCipher , typename T , typename K , typename OutputIterator >
OutputIterator nil::crypto3::encrypt ( std::initializer_list< T >  r,
std::initializer_list< K >  key,
OutputIterator  out 
)
Template Parameters
BlockCipher
T
KeyRange
OutputIterator
Parameters
r
key
out
Returns