nil::crypto3::pubkey Namespace Reference

Namespaces

 accumulators
 
 detail
 
 modes
 
 padding
 

Classes

struct  aggregate_op
 
struct  aggregate_op< bls< PublicParams, BlsVersion, BlsScheme, CurveType > >
 
struct  aggregate_verify_op
 
struct  aggregate_verify_op< bls< PublicParams, BlsVersion, BlsScheme, CurveType > >
 
struct  aggregate_verify_single_msg_op
 
struct  aggregate_verify_single_msg_op< bls< PublicParams, BlsVersion, bls_pop_scheme, CurveType > >
 
struct  agreement_key
 Key agreement refers to one form of key exchange in which two or more users execute a protocol to securely share a resultant key value. As an alternative to key agreement, a key transport protocol may be used. The distinguishing feature of a key agreement protocol is that participating users each contribute an equal portion toward the computation of the resultant shared key value (as opposed to one user computing and distributing a key value to other users). More...
 
struct  bls
 
struct  bls_aug_scheme
 
struct  bls_basic_scheme
 Basic BLS Scheme. More...
 
struct  bls_default_public_params
 
struct  bls_mps_ro_version
 
struct  bls_mss_ro_version
 
struct  bls_pop_prove_default_public_params
 
struct  bls_pop_scheme
 Proof of possession BLS Scheme. More...
 
struct  bls_pop_sign_default_public_params
 
struct  deal_share_op
 
struct  deal_share_op< pedersen_dkg< Group > >
 
struct  deal_shares_op
 
struct  deal_shares_op< feldman_sss< Group > >
 
struct  deal_shares_op< pedersen_dkg< Group > >
 
struct  deal_shares_op< shamir_sss< Group > >
 
struct  deal_shares_op< weighted_shamir_sss< Group > >
 
struct  ecdsa
 
struct  ecdsa< CurveType, Padding, random::rfc6979< GeneratorResultType, GeneratorHash >, DistributionType, typename std::enable_if< std::is_same< typename Padding::hash_type, GeneratorHash >::value &&std::is_same< typename CurveType::scalar_field_type::value_type, GeneratorResultType >::value >::type >
 
struct  eddsa
 
struct  eddsa< typename algebra::curves::curve25519::g1_type< Coordinates, algebra::curves::forms::twisted_edwards >, eddsa_variant, Params >
 
struct  eddsa_policy
 
struct  eddsa_policy< EddsaVariant::basic, Params >
 
struct  eddsa_policy< EddsaVariant::ctx, Params, typename std::enable_if< is_eddsa_params< Params >::value &&std::is_same< std::uint8_t, typename std::iterator_traits< typename Params::context_type::iterator >::value_type >::value >::type >
 
struct  eddsa_policy< EddsaVariant::ph, Params, typename std::enable_if< is_eddsa_params< Params >::value &&std::is_same< std::uint8_t, typename std::iterator_traits< typename Params::context_type::iterator >::value_type >::value >::type >
 
struct  feldman_sss
 
struct  is_bls
 
struct  is_bls< bls< PublicParams, BlsVersion, BlsScheme, CurveType > >
 
struct  is_eddsa_params
 
struct  is_feldman_sss
 
struct  is_feldman_sss< feldman_sss< Group > >
 
struct  is_pedersen_dkg
 
struct  is_pedersen_dkg< pedersen_dkg< Group > >
 
struct  is_shamir_sss
 
struct  is_shamir_sss< shamir_sss< Group > >
 
struct  is_weighted_shamir_sss
 
struct  is_weighted_shamir_sss< weighted_shamir_sss< Group > >
 
struct  pedersen_dkg
 
struct  private_key
 Private key - a key known only to its owner. Only the user keeping his private key secret guarantees the impossibility of forging a document and digital signature on behalf of the certifier by an attacker. More...
 
struct  private_key< bls< PublicParams, BlsVersion, BlsScheme, CurveType > >
 
struct  private_key< ecdsa< CurveType, Padding, GeneratorType, DistributionType >, typename std::enable_if< std::is_same< GeneratorType, random::rfc6979< typename CurveType::scalar_field_type::value_type, typename ecdsa< CurveType, Padding, GeneratorType, DistributionType >::hash_type > >::value >::type >
 
struct  private_key< ecdsa< CurveType, Padding, GeneratorType, DistributionType >, typename std::enable_if<!std::is_same< GeneratorType, random::rfc6979< typename CurveType::scalar_field_type::value_type, typename ecdsa< CurveType, Padding, GeneratorType, DistributionType >::hash_type > >::value >::type >
 
struct  private_key< eddsa< CurveGroup, eddsa_variant, Params > >
 
struct  public_key
 Public key - a key that can be published and used to verify the authenticity of the signed document, as well as to prevent fraud on the part of the certifying person in the form of his refusal to sign the document. More...
 
struct  public_key< bls< PublicParams, BlsVersion, BlsScheme, CurveType > >
 
struct  public_key< ecdsa< CurveType, Padding, GeneratorType, DistributionType > >
 
struct  public_key< eddsa< CurveGroup, eddsa_variant, Params > >
 
struct  public_secret_sss
 
struct  public_secret_sss< feldman_sss< Group > >
 
struct  public_secret_sss< pedersen_dkg< Group > >
 
struct  public_secret_sss< shamir_sss< Group > >
 
struct  public_share_sss
 
struct  public_share_sss< feldman_sss< Group > >
 
struct  public_share_sss< pedersen_dkg< Group > >
 
struct  public_share_sss< shamir_sss< Group > >
 
struct  public_share_sss< weighted_shamir_sss< Group > >
 
struct  reconstruct_public_secret_op
 
struct  reconstruct_public_secret_op< feldman_sss< Group > >
 
struct  reconstruct_public_secret_op< pedersen_dkg< Group > >
 
struct  reconstruct_public_secret_op< shamir_sss< Group > >
 
struct  reconstruct_secret_op
 
struct  reconstruct_secret_op< feldman_sss< Group > >
 
struct  reconstruct_secret_op< pedersen_dkg< Group > >
 
struct  reconstruct_secret_op< shamir_sss< Group > >
 
struct  reconstruct_secret_op< weighted_shamir_sss< Group > >
 
struct  secret_sss
 
struct  secret_sss< feldman_sss< Group > >
 
struct  secret_sss< pedersen_dkg< Group > >
 
struct  secret_sss< shamir_sss< Group > >
 
struct  secret_sss< weighted_shamir_sss< Group > >
 
struct  shamir_sss
 
struct  share_sss
 
struct  share_sss< feldman_sss< Group > >
 
struct  share_sss< pedersen_dkg< Group > >
 
struct  share_sss< shamir_sss< Group > >
 
struct  share_sss< weighted_shamir_sss< Group > >
 
struct  sss_basic_policy
 
struct  sss_weighted_basic_policy
 
struct  verify_share_op
 
struct  verify_share_op< feldman_sss< Group > >
 
struct  verify_share_op< pedersen_dkg< Group > >
 
struct  weighted_shamir_sss
 

Typedefs

template<typename ProcessingMode >
using aggregate_verification_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::aggregate_verify< ProcessingMode > >>
 Accumulator set with pre-defined aggregate verification accumulator params. More...
 
template<typename Scheme >
using aggregate_verification_policy = typename pubkey::modes::isomorphic< Scheme >::aggregate_verification_policy
 
template<typename Scheme >
using aggregate_verification_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< aggregate_verification_policy< Scheme > >::type
 
template<typename ProcessingMode >
using aggregation_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::aggregate< ProcessingMode > >>
 Accumulator set with pre-defined aggregation accumulator params. More...
 
template<typename Scheme >
using aggregation_policy = typename pubkey::modes::isomorphic< Scheme >::aggregation_policy
 
template<typename Scheme >
using aggregation_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< aggregation_policy< Scheme > >::type
 
template<typename Scheme >
using pop_proving_policy = typename pubkey::modes::isomorphic< Scheme >::pop_proving_policy
 
template<typename Scheme >
using pop_proving_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< pop_proving_policy< Scheme > >::type
 
template<typename Scheme >
using pop_verification_policy = typename pubkey::modes::isomorphic< Scheme >::pop_verification_policy
 
template<typename Scheme >
using pop_verification_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< pop_verification_policy< Scheme > >::type
 
template<typename Scheme >
using public_secret_reconstructing_policy = typename pubkey::modes::isomorphic< Scheme >::public_secret_reconstructing_policy
 
template<typename ProcessingMode >
using reconstructing_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::reconstruct< ProcessingMode > >>
 
template<typename Scheme >
using secret_reconstructing_policy = typename pubkey::modes::isomorphic< Scheme >::secret_reconstructing_policy
 
template<typename ProcessingMode >
using share_dealing_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::deal_share< ProcessingMode > >>
 
template<typename Scheme >
using share_dealing_policy = typename pubkey::modes::isomorphic< Scheme >::share_dealing_policy
 
template<typename Scheme >
using share_dealing_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< share_dealing_policy< Scheme > >::type
 
template<typename ProcessingMode >
using share_verification_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::verify_share< ProcessingMode > >>
 
template<typename Scheme >
using share_verification_policy = typename pubkey::modes::isomorphic< Scheme >::share_verification_policy
 
template<typename ProcessingMode >
using shares_dealing_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::deal_shares< ProcessingMode > >>
 
template<typename Scheme >
using shares_dealing_policy = typename modes::isomorphic< Scheme >::shares_dealing_policy
 
template<typename Scheme >
using shares_dealing_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< shares_dealing_policy< Scheme > >::type
 
template<typename ProcessingMode >
using signing_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::sign< ProcessingMode > >>
 Accumulator set with pre-defined signing accumulator params. More...
 
template<typename Scheme >
using signing_policy = typename pubkey::modes::isomorphic< Scheme >::signing_policy
 
template<typename Scheme >
using signing_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< signing_policy< Scheme > >::type
 
template<typename ProcessingMode >
using single_msg_aggregate_verification_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::aggregate_verify_single_msg< ProcessingMode > >>
 Accumulator set with pre-defined single message aggregate verification accumulator params. More...
 
template<typename Scheme >
using single_msg_aggregate_verification_policy = typename pubkey::modes::isomorphic< Scheme >::single_msg_aggregate_verification_policy
 
template<typename Scheme >
using single_msg_aggregate_verification_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< single_msg_aggregate_verification_policy< Scheme > >::type
 
template<typename ProcessingMode >
using verification_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::verify< ProcessingMode > >>
 Accumulator set with pre-defined verification accumulator params. More...
 
template<typename Scheme >
using verification_policy = typename pubkey::modes::isomorphic< Scheme >::verification_policy
 
template<typename Scheme >
using verification_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< verification_policy< Scheme > >::type
 

Enumerations

enum class  EddsaVariant { basic , ctx , ph }
 

Functions

template<typename Padding , typename SinglePassRange , typename OutputAccumulator = padding::encoding_accumulator_set<Padding>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type & encode (const SinglePassRange &r, OutputAccumulator &acc)
 
template<typename Padding , typename SinglePassRange , typename PaddingAccumulator = padding::encoding_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl encode (const SinglePassRange &rng)
 
template<typename Padding , typename SinglePassRange , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type encode (const SinglePassRange &rng, OutputIterator out)
 
template<typename Padding , typename InputIterator , typename PaddingAccumulator = padding::encoding_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl encode (InputIterator first, InputIterator last)
 
template<typename Padding , typename InputIterator , typename OutputAccumulator = padding::encoding_accumulator_set<Padding>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type & encode (InputIterator first, InputIterator last, OutputAccumulator &acc)
 
template<typename Padding , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type encode (InputIterator first, InputIterator last, OutputIterator out)
 
template<typename Padding , typename SinglePassRange , typename OutputAccumulator = padding::verification_accumulator_set<Padding>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type & verify (const SinglePassRange &r, OutputAccumulator &acc)
 
template<typename Padding , typename SinglePassRange , typename OutputIterator >
OutputIterator verify (const SinglePassRange &rng, OutputIterator out, typename Padding::msg_repr_type &msg_repr)
 
template<typename Padding , typename SinglePassRange , typename PaddingAccumulator = padding::verification_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl verify (const SinglePassRange &rng, typename Padding::msg_repr_type &msg_repr)
 
template<typename Padding , typename InputIterator , typename OutputAccumulator = padding::verification_accumulator_set<Padding>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< OutputAccumulator >::value, OutputAccumulator >::type & verify (InputIterator first, InputIterator last, OutputAccumulator &acc)
 
template<typename Padding , typename InputIterator , typename OutputIterator >
OutputIterator verify (InputIterator first, InputIterator last, OutputIterator out, typename Padding::msg_repr_type &msg_repr)
 
template<typename Padding , typename InputIterator , typename PaddingAccumulator = padding::verification_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl verify (InputIterator first, InputIterator last, typename Padding::msg_repr_type &msg_repr)
 

Typedef Documentation

◆ aggregate_verification_policy

◆ aggregate_verification_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::aggregate_verification_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<aggregate_verification_policy<Scheme> >::type

◆ aggregation_policy

template<typename Scheme >
using nil::crypto3::pubkey::aggregation_policy = typedef typename pubkey::modes::isomorphic<Scheme>::aggregation_policy

◆ aggregation_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::aggregation_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<aggregation_policy<Scheme> >::type

◆ pop_proving_policy

template<typename Scheme >
using nil::crypto3::pubkey::pop_proving_policy = typedef typename pubkey::modes::isomorphic<Scheme>::pop_proving_policy

◆ pop_proving_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::pop_proving_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<pop_proving_policy<Scheme> >::type

◆ pop_verification_policy

template<typename Scheme >
using nil::crypto3::pubkey::pop_verification_policy = typedef typename pubkey::modes::isomorphic<Scheme>::pop_verification_policy

◆ pop_verification_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::pop_verification_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<pop_verification_policy<Scheme> >::type

◆ public_secret_reconstructing_policy

◆ reconstructing_accumulator_set

template<typename ProcessingMode >
using nil::crypto3::pubkey::reconstructing_accumulator_set = typedef boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features<accumulators::tag::reconstruct<ProcessingMode> >>

◆ secret_reconstructing_policy

◆ share_dealing_accumulator_set

template<typename ProcessingMode >
using nil::crypto3::pubkey::share_dealing_accumulator_set = typedef boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features<accumulators::tag::deal_share<ProcessingMode> >>

◆ share_dealing_policy

template<typename Scheme >
using nil::crypto3::pubkey::share_dealing_policy = typedef typename pubkey::modes::isomorphic<Scheme>::share_dealing_policy

◆ share_dealing_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::share_dealing_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<share_dealing_policy<Scheme> >::type

◆ share_verification_accumulator_set

template<typename ProcessingMode >
using nil::crypto3::pubkey::share_verification_accumulator_set = typedef boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features<accumulators::tag::verify_share<ProcessingMode> >>

◆ share_verification_policy

template<typename Scheme >
using nil::crypto3::pubkey::share_verification_policy = typedef typename pubkey::modes::isomorphic<Scheme>::share_verification_policy

◆ shares_dealing_accumulator_set

template<typename ProcessingMode >
using nil::crypto3::pubkey::shares_dealing_accumulator_set = typedef boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features<accumulators::tag::deal_shares<ProcessingMode> >>

◆ shares_dealing_policy

template<typename Scheme >
using nil::crypto3::pubkey::shares_dealing_policy = typedef typename modes::isomorphic<Scheme>::shares_dealing_policy

◆ shares_dealing_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::shares_dealing_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<shares_dealing_policy<Scheme> >::type

◆ signing_policy

template<typename Scheme >
using nil::crypto3::pubkey::signing_policy = typedef typename pubkey::modes::isomorphic<Scheme>::signing_policy

◆ signing_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::signing_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<signing_policy<Scheme> >::type

◆ single_msg_aggregate_verification_policy

◆ single_msg_aggregate_verification_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::single_msg_aggregate_verification_processing_mode_default = typedef typename modes::isomorphic< Scheme>::template bind<single_msg_aggregate_verification_policy<Scheme> >::type

◆ verification_policy

template<typename Scheme >
using nil::crypto3::pubkey::verification_policy = typedef typename pubkey::modes::isomorphic<Scheme>::verification_policy

◆ verification_processing_mode_default

template<typename Scheme >
using nil::crypto3::pubkey::verification_processing_mode_default = typedef typename modes::isomorphic<Scheme>::template bind<verification_policy<Scheme> >::type

Enumeration Type Documentation

◆ EddsaVariant

Enumerator
basic 
ctx 
ph 

Function Documentation

◆ encode() [1/6]

template<typename Padding , typename SinglePassRange , typename OutputAccumulator = padding::encoding_accumulator_set<Padding>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::pubkey::encode ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
Padding
SinglePassRange
EncodingPolicy
OutputAccumulator
Parameters
r
acc
Returns

◆ encode() [2/6]

template<typename Padding , typename SinglePassRange , typename PaddingAccumulator = padding::encoding_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl nil::crypto3::pubkey::encode ( const SinglePassRange &  rng)
Template Parameters
Padding
SinglePassRange
Parameters
rng
Returns

◆ encode() [3/6]

template<typename Padding , typename SinglePassRange , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set<OutputIterator>::value, OutputIterator>::type nil::crypto3::pubkey::encode ( const SinglePassRange &  rng,
OutputIterator  out 
)
Template Parameters
Padding
SinglePassRange
OutputIterator
Parameters
rng
out
Returns

◆ encode() [4/6]

template<typename Padding , typename InputIterator , typename PaddingAccumulator = padding::encoding_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl nil::crypto3::pubkey::encode ( InputIterator  first,
InputIterator  last 
)
Template Parameters
Padding
InputIterator
Parameters
first
last
Returns

◆ encode() [5/6]

template<typename Padding , typename InputIterator , typename OutputAccumulator = padding::encoding_accumulator_set<Padding>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::pubkey::encode ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
Padding
InputIterator
EncodingPolicy
OutputAccumulator
Parameters
first
last
acc
Returns

◆ encode() [6/6]

template<typename Padding , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set<OutputIterator>::value, OutputIterator>::type nil::crypto3::pubkey::encode ( InputIterator  first,
InputIterator  last,
OutputIterator  out 
)
Template Parameters
Padding
InputIterator
OutputIterator
Parameters
first
last
out
Returns

◆ verify() [1/6]

template<typename Padding , typename SinglePassRange , typename OutputAccumulator = padding::verification_accumulator_set<Padding>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::pubkey::verify ( const SinglePassRange &  r,
OutputAccumulator &  acc 
)
Template Parameters
Padding
SinglePassRange
VerificationPolicy
OutputAccumulator
Parameters
r
acc
Returns

◆ verify() [2/6]

template<typename Padding , typename SinglePassRange , typename OutputIterator >
OutputIterator nil::crypto3::pubkey::verify ( const SinglePassRange &  rng,
OutputIterator  out,
typename Padding::msg_repr_type &  msg_repr 
)
Template Parameters
Padding
SinglePassRange
OutputIterator
Parameters
rng
out
Returns

◆ verify() [3/6]

template<typename Padding , typename SinglePassRange , typename PaddingAccumulator = padding::verification_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl nil::crypto3::pubkey::verify ( const SinglePassRange &  rng,
typename Padding::msg_repr_type &  msg_repr 
)
Template Parameters
Padding
SinglePassRange
Parameters
rng
Returns

◆ verify() [4/6]

template<typename Padding , typename InputIterator , typename OutputAccumulator = padding::verification_accumulator_set<Padding>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<OutputAccumulator>::value, OutputAccumulator>::type& nil::crypto3::pubkey::verify ( InputIterator  first,
InputIterator  last,
OutputAccumulator &  acc 
)
Template Parameters
Padding
InputIterator
VerificationPolicy
OutputAccumulator
Parameters
first
last
acc
Returns

◆ verify() [5/6]

template<typename Padding , typename InputIterator , typename OutputIterator >
OutputIterator nil::crypto3::pubkey::verify ( InputIterator  first,
InputIterator  last,
OutputIterator  out,
typename Padding::msg_repr_type &  msg_repr 
)
Template Parameters
Padding
InputIterator
OutputIterator
Parameters
first
last
out
Returns

◆ verify() [6/6]

template<typename Padding , typename InputIterator , typename PaddingAccumulator = padding::verification_accumulator_set<Padding>, typename StreamPaddingImpl = padding::detail::value_padding_impl<PaddingAccumulator>, typename PaddingImpl = padding::detail::range_padding_impl<StreamPaddingImpl>>
PaddingImpl nil::crypto3::pubkey::verify ( InputIterator  first,
InputIterator  last,
typename Padding::msg_repr_type &  msg_repr 
)
Template Parameters
Padding
InputIterator
Parameters
first
last
Returns