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  decrypt_op
 
struct  decrypt_op< elgamal_verifiable< Curve, BlockBits > >
 
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< eddsa_type::basic, Params >
 
struct  eddsa_policy< eddsa_type::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< eddsa_type::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  el_gamal
 
struct  el_gamal_private_key
 
struct  el_gamal_public_key
 
class  elgamal_verifiable
 
struct  encrypt_op
 
struct  encrypt_op< elgamal_verifiable< Curve, BlockBits > >
 
struct  feldman_sss
 
struct  generate_keypair_op
 
struct  generate_keypair_op< elgamal_verifiable< Curve, BlockBits > >
 
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  private_key< elgamal_verifiable< Curve, BlockBits > >
 
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_key< elgamal_verifiable< Curve, BlockBits > >
 
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  rerandomize_op
 
struct  rerandomize_op< elgamal_verifiable< Curve, BlockBits > >
 
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  verification_key
 
struct  verification_key< elgamal_verifiable< Curve, BlockBits > >
 
struct  verify_decryption_op
 
struct  verify_decryption_op< elgamal_verifiable< Curve, BlockBits > >
 
struct  verify_encryption_op
 
struct  verify_encryption_op< elgamal_verifiable< Curve, BlockBits > >
 
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 decryption_init_params_type = typename decrypt_op< Scheme >::init_params_type
 
template<typename Scheme >
using decryption_verification_init_params_type = typename verify_decryption_op< Scheme >::init_params_type
 
template<typename Scheme >
using encryption_init_params_type = typename encrypt_op< Scheme >::init_params_type
 
template<typename Scheme >
using encryption_verification_init_params_type = typename verify_encryption_op< Scheme >::init_params_type
 
template<typename Scheme >
using keypair_generation_init_params_type = typename generate_keypair_op< Scheme >::init_params_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 ProcessingMode >
using pubkey_accumulator_set = boost::accumulators::accumulator_set< typename ProcessingMode::result_type, boost::accumulators::features< accumulators::tag::pubkey< ProcessingMode > >>
 
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 rerandomization_init_params_type = typename rerandomize_op< Scheme >::init_params_type
 
template<typename Scheme >
using secret_reconstructing_policy = typename pubkey::modes::isomorphic< Scheme >::secret_reconstructing_policy
 
template<typename Scheme >
using secret_reconstructing_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< secret_reconstructing_policy< Scheme > >::type
 
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 Scheme >
using share_verification_processing_mode_default = typename modes::isomorphic< Scheme >::template bind< share_verification_policy< Scheme > >::type
 
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  eddsa_type { 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

◆ decryption_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::decryption_init_params_type = typedef typename decrypt_op<Scheme>::init_params_type

◆ decryption_verification_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::decryption_verification_init_params_type = typedef typename verify_decryption_op<Scheme>::init_params_type

◆ encryption_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::encryption_init_params_type = typedef typename encrypt_op<Scheme>::init_params_type

◆ encryption_verification_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::encryption_verification_init_params_type = typedef typename verify_encryption_op<Scheme>::init_params_type

◆ keypair_generation_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::keypair_generation_init_params_type = typedef typename generate_keypair_op<Scheme>::init_params_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

◆ pubkey_accumulator_set

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

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

◆ rerandomization_init_params_type

template<typename Scheme >
using nil::crypto3::pubkey::rerandomization_init_params_type = typedef typename rerandomize_op<Scheme>::init_params_type

◆ secret_reconstructing_policy

◆ secret_reconstructing_processing_mode_default

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

◆ 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

◆ share_verification_processing_mode_default

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

◆ 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

◆ eddsa_type

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